Add Batch f437104a-1b19-49e4-bd66-b357b0d8eeb1

.gitattributes

@@ -8908,3 +8908,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 2203.11xxx/2203.11941/3d477d2f-3b43-4365-a4c7-3ee962e7266d_origin.pdf filter=lfs diff=lfs merge=lfs -text
 2201.07xxx/2201.07211/6f4f7845-69d0-47da-a6c8-c27b41ddefb8_origin.pdf filter=lfs diff=lfs merge=lfs -text
 2201.04xxx/2201.04944/9304506d-347f-4b61-b827-6c63e9db0b54_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2203.02xxx/2203.02697/9f953933-84bb-40cc-b218-d16d7f5c68c3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2203.02xxx/2203.02700/3d69ca7f-39a5-4c99-b9df-bcb921fe9d04_origin.pdf filter=lfs diff=lfs merge=lfs -text
+2203.02xxx/2203.02719/6a2a0cc6-43cc-4438-b5c9-38412d95a76d_origin.pdf filter=lfs diff=lfs merge=lfs -text

2203.02xxx/2203.02697/9f953933-84bb-40cc-b218-d16d7f5c68c3_content_list.json

@@ -0,0 +1,1986 @@
+[
+    {
+        "type": "text",
+        "text": "Pareto Optimization or Cascaded Weighted Sum: A Comparison of Concepts",
+        "text_level": 1,
+        "bbox": [
+            77,
+            198,
+            722,
+            247
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wilfried Jakob  $^{1, *}$  and Christian Blume",
+        "bbox": [
+            77,
+            263,
+            436,
+            280
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "$^{1}$  Karlsruhe Institute of Technology (KIT), Institute of Applied Computer Science (IAI), P.O. Box 3640, Karlsruhe 76021, Germany",
+            "$^{2}$  Cologne University of Applied Sciences, Institute of Automation and Industrial IT, Steinmüllerallee 1, Gummersbach 51643, Germany; E-Mail: blume@gm.fh-koeln.de",
+            "* Author to whom correspondence should be addressed; E-Mail: wilfried.jakob@kit.edu; Tel.: +49-721-608-24663; Fax: +49-721-608-22602."
+        ],
+        "bbox": [
+            77,
+            297,
+            810,
+            430
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Received: 22 January 2014; in revised form: 3 March 2014 / Accepted: 14 March 2014 /",
+        "bbox": [
+            77,
+            449,
+            803,
+            466
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Published: 21 March 2014",
+        "bbox": [
+            80,
+            469,
+            300,
+            483
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract: Looking at articles or conference papers published since the turn of the century, Pareto optimization is the dominating assessment method for multi-objective nonlinear optimization problems. However, is it always the method of choice for real-world applications, where either more than four objectives have to be considered, or the same type of task is repeated again and again with only minor modifications, in an automated optimization or planning process? This paper presents a classification of application scenarios and compares the Pareto approach with an extended version of the weighted sum, called cascaded weighted sum, for the different scenarios. Its range of application within the field of multi-objective optimization is discussed as well as its strengths and weaknesses.",
+        "bbox": [
+            124,
+            526,
+            870,
+            703
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Keywords: multi-criteria optimization; Pareto optimization; weighted sum; cascaded weighted sum; global optimization; population based optimization; evolutionary algorithm",
+        "bbox": [
+            124,
+            721,
+            870,
+            760
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. Introduction",
+        "text_level": 1,
+        "bbox": [
+            78,
+            813,
+            213,
+            829
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most nonlinear real-world optimization problems require the optimization of several objectives and usually at least some of them are contradictory. A simple example of two conflicting criteria is the payload and the traveling distance with a given amount of fuel, which cannot be maximized both at the same time. The typical solution of such a problem is a compromise. A good compromise is one",
+        "bbox": [
+            75,
+            847,
+            917,
+            926
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7, 166-185; doi:10.3390/a7010166",
+        "bbox": [
+            77,
+            61,
+            509,
+            80
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "header",
+        "text": "OPEN ACCESS",
+        "bbox": [
+            783,
+            77,
+            917,
+            91
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "header",
+        "text": "algorithms",
+        "bbox": [
+            702,
+            97,
+            914,
+            130
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "header",
+        "text": "ISSN 1999-4893",
+        "bbox": [
+            776,
+            131,
+            915,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "header",
+        "text": "www.mdpi.com/journal/algorithms",
+        "bbox": [
+            628,
+            148,
+            915,
+            164
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "header",
+        "text": "Article",
+        "bbox": [
+            77,
+            167,
+            139,
+            181
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where one of the criteria can be improved only by worsening at least one of the others. This approach is called Pareto optimization [1], and the set of all good compromises is called Pareto optimal solutions or non-dominated solutions. In practice, usually only one solution is required. Thus, multi-objective optimization based on Pareto optimality is divided into two phases: At first, the set of Pareto optimal solutions is determined, out of which one must be chosen as the final result by a human decision maker according to more or less subjective preferences. This is in contrast to single-objective optimization tasks, where no second selection step is required.",
+        "bbox": [
+            80,
+            93,
+            917,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Most population-based search procedures, like evolutionary algorithms, particle swarm or ant colony optimization, require a single quality value called e.g., fitness in the context of evolutionary algorithms. This may be one reason for the frequent aggregation of different optimization criteria to a single quality value. Two methods, the frequently used weighted sum and the  $\\varepsilon$ -constrained method, are described briefly. Another commonly used method is to express everything in costs. On closer inspection, it becomes apparent that this is equal to the weighted sum approach using suitable weights. Additionally, the conversion into costs requires an artificial redefinition of the original goals and this is often not really appropriate. Thus, most multi-objective optimization problems have meanwhile been solved based on Pareto optimization, at least in academia.",
+        "bbox": [
+            80,
+            235,
+            917,
+            413
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The computational effort to determine all or at least most of the Pareto front increases significantly with the number of conflicting objectives, as will be shown later in the paper. However, what if the complete Pareto front is not needed at all, because the area of interest is already known? In this paper we will introduce an aggregation method called the cascaded weighted sum (CWS) and discuss application scenarios, where aggregation methods like the CWS can compete with Pareto-optimality-based approaches. Not to be misunderstood: We agree that in many fields of application, Pareto optimization is the appropriate method for multi-objective problems. Although we will concentrate on evolutionary multi-objective optimization later in the paper, the issues discussed here can be applied to other global optimization procedures as well and especially to those, which optimize a set of solutions simultaneously instead of just one.",
+        "bbox": [
+            80,
+            417,
+            917,
+            617
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The paper is organized as follows: In Section 2 the basics of Pareto optimization are described, followed by the weighted sum and the  $\\varepsilon$ -constrained method, including a brief discussion of their properties. In Section 3, the cascaded weighted sum is introduced. Section 4 starts with a classification of application scenarios, gives some examples, and discusses the question for which scenario which method is suited better or how they can complement each other. The paper closes in Section 5 with a summary and a conclusion.",
+        "bbox": [
+            80,
+            619,
+            917,
+            737
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. Short Introduction to Pareto Optimization and Two Aggregation Methods",
+        "text_level": 1,
+        "bbox": [
+            82,
+            753,
+            741,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on Hoffmeister and Bäck [2], and the notation of Branke et al. [3], a multi-objective optimization problem is the task of maximizing a set of  $k (>1)$  usually conflicting objective functions  $f_{i}$  simultaneously, denoted by maximize  $\\{...\\}$ :",
+        "bbox": [
+            82,
+            788,
+            917,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\begin{array}{l} \\text {m a x i m i z e} \\left\\{f _ {1} (x), f _ {2} (x), \\dots , f _ {k} (x) \\right\\}, x \\in S \\\\ f _ {i}: S \\subseteq S _ {1} \\times \\dots \\times S _ {n} \\rightarrow \\Re , S \\neq \\emptyset \\tag {1} \\\\ \\end{array}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            854,
+            912,
+            901
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "page_number",
+        "text": "167",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The focus on maximization is without loss of generality, because  $\\min \\{f(x)\\} = -\\max \\{-f(x)\\}$ . The nonempty set  $S$  is called the feasible region and a member of it is called a decision (variable) vector  $x = (x_{1}, x_{2}, \\ldots, x_{n})^{T}$ . As it is of no further interest here, we do not describe the constraints forming  $S$  in more detail. Frequently, the  $S_{i}$  are the set of real or whole numbers or a subset thereof, but they can be any arbitrary set as well. Objective vectors are images of decision vectors, consisting of objective (function) values  $z = f(x) = (f_{1}(x), f_{2}(x), \\ldots, f_{k}(x))^{T}$ . Accordingly, the image of the feasible region in the objective space is called the feasible objective region  $Z = f(S)$ . Figure 1 illustrates this.",
+        "bbox": [
+            75,
+            89,
+            919,
+            235
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0235fe3a5ca0707d49866992d60c0adb72dc14f557ef17efa0789b8ea11194b5.jpg",
+        "image_caption": [
+            "Figure 1. Feasible region  $S$  and its image, the feasible objective region  $Z$  for  $n = k = 2$ . The set of weakly Pareto optimal solutions is shown as a bold green line in the diagram on the right. The subset of Pareto optimal solutions is the part of the green line between the black circles. The ideal objective vector  $z^*$  consists of the upper bounds of the Pareto set."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            132,
+            341,
+            867,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following sections Pareto optimization and two frequently used aggregation methods, which turn a multi-objective problem into a single-objective task, are introduced and compared in the end.",
+        "bbox": [
+            75,
+            563,
+            915,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1. Pareto Optimization",
+        "text_level": 1,
+        "bbox": [
+            77,
+            618,
+            284,
+            634
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A decision vector  $x \\in S$  dominates another vector  $y \\in S$ , if",
+        "bbox": [
+            100,
+            650,
+            588,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\begin{array}{l} \\forall i \\in \\{1, 2, \\dots , k \\}: f _ {i} (x) \\geq f _ {i} (y) a n d \\\\ \\exists j \\in \\{1, 2, \\dots , k \\}: f _ {j} (x) > f _ {j} (y) \\tag {2} \\\\ \\end{array}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            673,
+            912,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A decision vector  $x' \\in S$ , which is not dominated by any other  $x \\in S$ , is called Pareto optimal. The objective vector  $z' = f(x')$  is Pareto optimal, if the corresponding decision vector is Pareto optimal and the corresponding sets can be denoted by  $P(S)$  and  $P(Z)$ . The set of weakly Pareto optimal solutions, which is a superset of the set of Pareto optimal solutions, is formed by decision vectors, for which the following applies: An  $x' \\in S$  is called weakly Pareto optimal, if no other  $x \\in S$  exists such that  $f_i(x) > f_i(x')$  for all  $i = 1, \\ldots, k$ . As the set of Pareto optimal solutions consists of decision vectors only, which are not dominated, they can be regarded as the set of good compromises mentioned in the introduction. It follows from the definition that they are located on the border of the feasible objective region, as shown in the right part of Figure 1. The figure also illustrates the concept of weakly Pareto optimal solutions lying on the part of the green line outside of the section bounded by the black circles",
+        "bbox": [
+            75,
+            728,
+            919,
+            932
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            77,
+            53,
+            240,
+            70
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "page_number",
+        "text": "168",
+        "bbox": [
+            882,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "in the given example. It should be stated that the set of Pareto optimal solutions does not need to be as nicely shaped as shown in Figure 1; it may also be non-convex and disconnected.",
+        "bbox": [
+            80,
+            93,
+            917,
+            130
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The upper bounds of the Pareto optimal set can be obtained by maximizing the  $f_{i}$  individually with respect to the feasible region. This results in the ideal objective vector  $z^{*}\\in \\Re^{k}$ , an example of which is shown for the two-dimensional case in the right part of Figure 1. The lower bounds are usually hard to determine, see [3]. Although Pareto-based search methods can provide valuable estimations of the ranges of the objectives for practical applications, they are not suited for an exact determination of their lower and upper bounds.",
+        "bbox": [
+            78,
+            134,
+            917,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "According to [4], constraints in the objective space are handled as follows: A solution  $x$  constrained-dominates a solution  $y$ , if any of the three conditions is satisfied:",
+        "bbox": [
+            80,
+            255,
+            917,
+            292
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- Solution  $x$  is feasible and  $y$  is not.",
+            "- Both solutions are feasible and  $x$  dominates  $y$ .",
+            "- Both solutions are infeasible, but  $x$  has a smaller constrained violation than  $y$ . If more than one constraint is violated, the violations are normalized, summed up, and compared."
+        ],
+        "bbox": [
+            100,
+            303,
+            914,
+            379
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hereinafter, the term Pareto optimization is used for an optimization procedure employing Pareto optimality to assess and compare generated solutions.",
+        "bbox": [
+            80,
+            390,
+            917,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2. Weighted Sum",
+        "text_level": 1,
+        "bbox": [
+            80,
+            445,
+            235,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One of the probably most often used assessment methods besides Pareto optimality is the weighted sum, which aggregates the objective values to a single quality measure. As the objective functions frequently have different scales, they are usually normalized. This can be done for example by using Equations (3) or (4) when minimizing and maximizing the objectives, respectively:",
+        "bbox": [
+            80,
+            479,
+            917,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nf _ {i} ^ {\\text {n o r m}} = \\frac {\\max \\left(f _ {i}\\right) - f _ {i}}{\\max \\left(f _ {i}\\right) - \\min \\left(f _ {i}\\right)} \\text {f o r o b j e c t i v e s t o b e m i n i m i z e d} \\tag {3}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            564,
+            912,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nf _ {i} ^ {\\text {n o r m}} = 1 - \\frac {\\max \\left(f _ {i}\\right) - f _ {i}}{\\max \\left(f _ {i}\\right) - \\min \\left(f _ {i}\\right)} \\text {f o r o b j e c t i v e s t o b e m a x i m i z e d} \\tag {4}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            252,
+            613,
+            912,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The bounds of the objective function  $fi$  can be estimated or are the result of a maximization of each function individually in case of  $\\max(f_i)$ . For the calculation of the weighted sum as shown in Equation (5), a weight  $w_i$  has to be chosen for every objective:",
+        "bbox": [
+            80,
+            665,
+            917,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {m a x i m i z e} \\sum_ {i = 1} ^ {k} w _ {i} f _ {i} ^ {\\text {n o r m}} (x), \\quad x \\in S \\text {w h e r e} w _ {i} > 0 \\text {f o r a l l} i = 1, \\dots , k \\text {a n d} \\sum_ {i = 1} ^ {k} w _ {i} = 1 \\tag {5}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            176,
+            731,
+            912,
+            766
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By varying the weights, any point of a convex Pareto front can be obtained. Figure 2 illustrates this: The straight line corresponding to the chosen weights  $w_{1}$  and  $w_{2}$  is moved towards the border of the feasible objective region during the optimization process and becomes a tangent in point P. The solutions found are Pareto optimal, see [5].",
+        "bbox": [
+            80,
+            780,
+            917,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, it is possible that parts of the Pareto front cannot be found in case of a non-convex problem. This is illustrated in Figure 3: the part between points A and B of the Pareto front cannot be obtained for any weights. This is a serious drawback.",
+        "bbox": [
+            80,
+            860,
+            917,
+            917
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_number",
+        "text": "169",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4f9e3bf301ec55325cc194f2ba779a15611d8fe6a771daa5b8d4fd1469e3ddf.jpg",
+        "image_caption": [
+            "Figure 2. By using appropriate weights, every point of a convex Pareto front can be achieved by the weighted sum. Here, point  $\\mathbf{P}$  can be obtained for the weights  $w_{1}$  and  $w_{2}$ . The arrows show the movement direction of points where the largest quality gain is obtained."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            329,
+            162,
+            663,
+            370
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6bab592db324588f3c9cf05c876c9f1d43677f1a32cd1ee911d349aad6f40dfe.jpg",
+        "image_caption": [
+            "Figure 3. For non-convex Pareto fronts, it is possible that parts of the front can not be obtained by the weighted sum. The region between points  $\\mathbf{A}$  and  $\\mathbf{B}$  is an example of this serious draw back of this aggregation method."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            329,
+            460,
+            663,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, the weighted sum is often used for practical applications. Reasons are the simplicity of its application and the easy way to integrate restrictions, which are beyond pure limitations of the feasible region. Examples are scheduling tasks, where the jobs to be scheduled have due dates for finalization. Thus, delays can occur and it is not sufficient to tell the search procedure that this constrained violation is an infeasible solution by e.g., rejecting it. Instead, the search must be guided out of the infeasible region by rewarding a reduction of the violation. In the example given, this can be done by counting the number of jobs involved and summing up the amounts of delays, see e.g., [6]. These two key figures can either become new objectives or can be treated as penalty functions. As they do not represent wanted properties and as a low number of objectives is preferable, penalty functions are the method of choice. They can be designed to yield values between zero (maximal violation) and one (no violation). The results of all penalty functions serve as factors by which the weighted sum is multiplied. As a result, the pure weighted sum turns into a raw quality measure, which represents the solution quality of the problem without constraints, while the final",
+        "bbox": [
+            80,
+            678,
+            917,
+            938
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_number",
+        "text": "170",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "product represents the solution for the task with its constraints. Figure 4 shows a typical example of such a penalty function. If the maximum value of constraint violation is hard to predict, as it is often the case, an exponential function can be chosen. A value of delay  $dp$  for poor solutions can usually be estimated roughly and the exponential function is attributed such that it yields a value of  $\\frac{1}{3}$  in this case.",
+        "bbox": [
+            75,
+            93,
+            917,
+            173
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab2a667072480f1ad928a31d483490be74c166aa2075ce68a412d48af4ca7f27.jpg",
+        "image_caption": [
+            "Figure 4. Example of a penalty function. It turns constraint violations into a penalty value between 1 and 0, which serves as a factor for decreasing the weighted sum."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            257,
+            243,
+            742,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.3.  $\\varepsilon$ -Constrained Method",
+        "text_level": 1,
+        "bbox": [
+            78,
+            473,
+            302,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The  $\\varepsilon$ -constrained method is based on the optimization of one selected objective function  $f_{j}$  and treating the others as constraints [7]. The optimization problem now has the form",
+        "bbox": [
+            75,
+            508,
+            917,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\begin{array}{l} \\text {m a x i m i z e} f _ {j} (x), \\quad x \\in S, \\quad j \\in \\{1, \\dots , k \\} \\\\ f _ {i} (x) \\geq \\varepsilon_ {i} \\text {f o r a l l} i = 1, \\dots , k, i \\neq j \\tag {6} \\\\ \\end{array}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            317,
+            551,
+            912,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The  $\\varepsilon_{j}$  are the lower bounds for those objective functions that are treated as constraints. For practical applications, the appropriate bounds must be selected carefully. In particular, it must be ensured that the bounds are within the feasible objective region, because otherwise the resulting problem would have no solutions. Ośczyka gives suggestions for a systematic selection of values for the  $\\varepsilon_{j}$  and illustrates them with sample applications [8].",
+        "bbox": [
+            75,
+            613,
+            917,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 gives an example based on the feasible region shown in Figure 3. In Figure  $5f_{2}$  is treated as a constraint with the lower bound  $\\varepsilon_{2}$ . Thus, the remaining Pareto front is the section between the points F1 and F2. The figure also shows the main movement direction of solutions in  $Z$  that have exceeded the threshold  $\\varepsilon_{2}$ . The main movement direction results from the optimization. Move components up- and downwards are also possible, but are not considered by the assessment procedure of this method as long as they do not drop below  $\\varepsilon_{2}$ . A too large value of the constraint like  $\\varepsilon_{bad}$  would make the problem unsolvable.",
+        "bbox": [
+            75,
+            714,
+            917,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A decision vector  $x' \\in S$  is Pareto-optimal, if and only if it solves Equation (6) for every  $j = 1, \\dots, k$ , where  $\\varepsilon_i = f_i(x')$  for  $i = 1, \\dots, k, i \\neq j$ , see [9]. This means that  $k$  different problems must be solved for every member of the Pareto front, which can be expected to be computationally costly. If the task can be relaxed to weak Pareto optimality, only one solution of Equation (6) per member of",
+        "bbox": [
+            77,
+            854,
+            919,
+            936
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            53,
+            240,
+            71
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "page_number",
+        "text": "171",
+        "bbox": [
+            882,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "the front is required [9]. On the other hand, the method does not require convexity for finding any Pareto-optimal solution.",
+        "bbox": [
+            80,
+            93,
+            917,
+            130
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/50165a7bfbef8f28979176d94d7757146949ad85567743afeac10e6955a98b83.jpg",
+        "image_caption": [
+            "Figure 5. Restricted objective region using the  $\\varepsilon$ -constrained method. The hatched region is excluded due to the lower bound  $\\varepsilon_{2}$ . The remaining Pareto front is limited by F1 and F2. For too large bounds like  $\\varepsilon_{bad}$ , the problem becomes unsolvable."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            327,
+            219,
+            673,
+            419
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2.4. Summary",
+        "text_level": 1,
+        "bbox": [
+            80,
+            439,
+            194,
+            456
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The two aggregation procedures (More aggregation methods can be found in [9].) can both find any Pareto-optimal solution for convex problems and the  $\\varepsilon$ -constrained method can do that for non-convex tasks, too. This advantage of the  $\\varepsilon$ -constrained method goes at the expense of higher computational costs: For finding a Pareto-optimal solution, the  $\\varepsilon$ -constrained method needs to solve  $k$  different problems, whereas the weighted sum needs to solve just one per element of the Pareto set.",
+        "bbox": [
+            80,
+            473,
+            917,
+            571
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another important issue is the manageability. Depending on the problem, it can be assumed that it is easier for experts in the application area to estimate lower bounds for objectives than weights, which are more abstract. Experts are usually familiar with objective values and they are intelligible for them as such.",
+        "bbox": [
+            80,
+            574,
+            917,
+            652
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For optimization procedures working with a set of solutions, frequently called population, like Evolutionary Algorithms (EAs), Ant Colony (ACO) or Particle Swarm Optimization (PSO), or the like, the advantage for multi-objective optimization is the ability to determine, in principle, the entire Pareto front at once. Of course, an optimization procedure must be adapted such that it spreads the population to the Pareto front as best as possible instead of concentrating on some areas of it. Examples of such adapted procedures in the EA field are the non-dominated sorting Genetic Algorithm (NSGA-II) [10], the Strength Pareto EA (SPEA-2) [11], or the S-metric selection evolutionary multi-objective optimization algorithm (SMS-EMOA) [12], to mention only a few. These combinations of population-based optimization procedures and Pareto optimality in general will estimate the Pareto front roughly at the minimum, with less computational effort than it can be done using the aggregation methods introduced for the assessment of the individuals of the same population-based methods. In the latter case, about as many runs would be required as solutions should occupy the Pareto front. Thus, these algorithms specialized for finding as much of the Pareto front as possible in one run are the",
+        "bbox": [
+            80,
+            656,
+            919,
+            915
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "page_number",
+        "text": "172",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "methods of choice for new problems, where little is known in advance and where a human decision maker is available to make the final choice.",
+        "bbox": [
+            80,
+            93,
+            917,
+            129
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3. Cascaded Weighted Sum",
+        "text_level": 1,
+        "bbox": [
+            80,
+            147,
+            317,
+            165
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have been using this extended version of the weighted sum since the inception of our Evolutionary Algorithm GLEAM (General Learning and Evolutionary Algorithm and Method) in 1990 [13], as we considered this assessment method a convenient way to steer the evolutionary search process for evolving improved collision-free robot move trajectories [13,14]. As we did not regard it as something special, we did not publish it in English (A detailed description in German of the cascaded weighted sum and all variants of the application of GLEAM to industrial robot path planning for several industrial robots can be found in [15]). until comments of reviewers of other publications on GLEAM changed our mind and revealed the need for a general discussion. Some impacts of the robot application on the evaluation of solutions are discussed later in Sections 4.2 and 4.3.3. Before the cascaded weighted sum is described, we will shortly introduce Evolutionary Algorithms and GLEAM in particular to the extent necessary for a better understanding of the following sections.",
+        "bbox": [
+            80,
+            181,
+            917,
+            401
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.1. Short Introduction to Evolutionary Algorithms and GLEAM",
+        "text_level": 1,
+        "bbox": [
+            80,
+            418,
+            601,
+            435
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evolutionary Algorithms (EA) typically conduct a search in the feasible region, with this search being guided by a quality function usually called fitness function. The search is done in parallel by a set of solution candidates, called individuals, forming a population. If an individual is outside of the feasible region, it will be guided back by one or more penalty functions or comparable techniques. The fitness function may be one of the aggregation methods described above. Alternatively, it is guided by Pareto optimality and is therefore based on the amount of dominated solutions and possibly some other measure, which rewards a good spread of the non-dominated solutions along the Pareto front, see e.g., [10,12]. New solutions are generated by stochastic algorithmic counterparts of the two biological archetypes mutation and recombination, for which an individual selects a partner frequently influenced by the fitness. Thus, the generated offspring inherits properties from both parents. The third principle of evolution, the survival of the fittest, occurs when deciding about who is included in the next iteration. In elitist forms of EAs, the best individual survives always and therefore, the quality of the population can increase only. On the other hand, convergence cannot be ensured within limited time. To avoid premature convergence, various attempts have been made to maintain genotypic diversity for a longer period of time by establishing niches within the population, see e.g., [16-18]. GLEAM uses one of these methods [16] (An actual description of the diffusion model and its integration into GLEAM can be found in [19].) and, thus, frequently yields some distinct solutions of more or less comparable quality. Iterative, stochastic, and population-based optimization procedures in general tend to produce some variants of the best solution. How much they differ in properties and quality depends on the algorithm, the actions taken for maintaining diversity, and the length of the run.",
+        "bbox": [
+            80,
+            454,
+            919,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            80,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_number",
+        "text": "173",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2. Definition of the Cascaded Weighted Sum",
+        "text_level": 1,
+        "bbox": [
+            78,
+            93,
+            455,
+            111
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the cascaded weighted sum (CWS) each objective is assigned a weight  $w_{i}$  as with the pure weighted sum and a priority starting with 1 as the highest one. If desired, some objectives may have the same priority. All objectives but those with the lowest priority receive a user-given threshold  $\\varepsilon_{i}$ . In the beginning, only the objectives of the highest priority are active and contribute to the weighted sum. The others are activated according to the following priority rule:",
+        "bbox": [
+            75,
+            128,
+            917,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "If all objectives with the same priority exceed their threshold, the objectives of the next lower priority are activated and their values are added to the sum.",
+        "bbox": [
+            121,
+            237,
+            875,
+            278
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As the objectives are grouped by the priorities and the groups are considered one after the other, the method is called cascaded weighted sum. A group whose members exceed their threshold is called a satisfied group. If at least one objective of a satisfied group drops below its threshold, the group is not satisfied anymore and consequently, all groups with lower priorities are deactivated, which will significantly reduce the resulting weighted sum.",
+        "bbox": [
+            75,
+            294,
+            917,
+            393
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the formal definition of the CWS given in Equation (7), the original  $f_{i}(x)$  are used for the threshold value checks rather than their normalized counterparts, as we assume that this is more convenient for experts of the application. The  $k$  objectives are sorted according to their priorities and we have  $g$  objective groups, where  $1 < g \\leq k$ . For  $g = 1$ , the CWS would be identical with the weighted sum. Each group consists of  $m_{j}$  objectives, the sum of which is  $k$ . As with the original weighted sum, each  $w_{i} > 0$  and  $\\sum_{i=1}^{k} w_{i} = 1$ .",
+        "bbox": [
+            75,
+            395,
+            917,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As there are differences for the first and the last priority group, Equation (7) shows the objectives contributing to the weighted sum for the highest priority 1, the general case of priority  $j$ , and the lowest priority  $g$ .",
+        "bbox": [
+            75,
+            537,
+            917,
+            596
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Priority 1: if not all  $f_{i}(x) \\geq \\varepsilon_{i} \\forall i = 1, \\ldots, m_{1}$",
+        "bbox": [
+            77,
+            602,
+            512,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(highest priority) maximize  $\\sum_{i = 1}^{m}w_{i}f_{i}^{\\text{norm}}(x), x\\in S, m = m_{1}$",
+        "bbox": [
+            80,
+            625,
+            623,
+            661
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Priority  $j$  : if all  $f_{i}(x)\\geq \\varepsilon_{i}\\quad \\forall i = 1,\\ldots ,l_{j}$  and  $l_{j} = \\sum_{l = 1}^{j - 1}m_{l}$  (satisfied groups)",
+        "bbox": [
+            78,
+            665,
+            779,
+            703
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "not all  $f_{i}(x)\\geq \\varepsilon_{i}\\quad \\forall i = l_{j} + 1,\\ldots ,l_{j} + m_{j}$  maximize  $\\sum_{i = 1}^{m}w_{i}f_{i}^{\\mathrm{norm}}(x),\\quad x\\in S,\\quad m = l_{j} + m_{j}$  (7)",
+        "bbox": [
+            80,
+            703,
+            902,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Priority  $g$  : if all  $f_{i}(x)\\geq \\varepsilon_{i}\\quad \\forall i = 1,\\ldots ,l_{g},\\quad l_{g} = \\sum_{l = 1}^{g - 1}m_{l}$  (satisfied groups) (lowest priority)",
+        "bbox": [
+            78,
+            768,
+            779,
+            807
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\text {m a x i m i z e} \\sum_ {i = 1} ^ {k} w _ {i} f _ {i} ^ {\\text {n o r m}} (x), x \\in S\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            280,
+            809,
+            544,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Once a group is satisfied, the total quality value is increased abruptly by the values from the next activated group, which they can lose, if only one objective of a group with higher priority undergoes its  $\\varepsilon_{i}$ . This makes it very unlikely for more successful solutions that the once gained values of the already contributing objectives drop below their thresholds in the course of further search.",
+        "bbox": [
+            75,
+            859,
+            917,
+            938
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            53,
+            240,
+            71
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "page_number",
+        "text": "174",
+        "bbox": [
+            882,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The selection of appropriate weights and threshold values requires some knowledge about the problem at hand, including one or more preparative Pareto optimization runs as illustrated in the next section. Thus, neither the original weighted sum nor the CWS are a priori methods. We will come back to this later.",
+        "bbox": [
+            80,
+            93,
+            917,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "3.3. Example of the CWS",
+        "text_level": 1,
+        "bbox": [
+            82,
+            187,
+            285,
+            206
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 1 gives an example of the usage of weights and thresholds for a problem of scheduling jobs organized in workflows of elementary operations to heterogeneous equipment comparable to the one described in [6]. All operations can be assigned to alternatively usable equipment at different costs and processing times. The task is to produce schedules, where the job processing is as cheap and as fast as possible and each job observes a given budget and a given due date. The rate of utilization of the equipment should be as high and the total makespan of all jobs as low as possible. Additionally, the schedules must be updated frequently, because e.g., new jobs arrive or waiting jobs are cancelled. As described in Section 2.2, all objectives are normalized according to Equation (3). The required limits are obtained as follows: The bounds of job time and costs are calculated by determination of the critical path of the workflow of that job and by the assignment of the fastest/slowest or costliest/cheapest equipment suited for the operations of a job. The user-given due dates and cost limits are checked against these bounds so that the subsequent scheduling is based on goals which are achievable in principle. The lower bound of the makespan is the duration of the longest lasting job using the fastest equipment and the upper bound is the sum of the duration of all jobs using the slowest equipment divided by the smallest number of alternatively usable equipment. As the rate of utilization already yields a value to be maximized between zero and one, there is no need for bounds.",
+        "bbox": [
+            80,
+            223,
+            917,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/376598e1d44207217b1adf5eea053dda4cedc4bab00d4759bb1c2e95452b1729.jpg",
+        "table_caption": [
+            "Table 1. Example of the use of the cascaded weighted sum (CWS) and the effect of objective group weights. The objectives with the highest priority are always active and contribute to the weighted sum. They are marked here by a light green background."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Priority</td><td>Objective</td><td>Weight [%]</td><td>Threshold εi</td></tr><tr><td>1</td><td>job time</td><td>30</td><td>0.4</td></tr><tr><td>1</td><td>job costs</td><td>40</td><td>0.25</td></tr><tr><td>2</td><td>makespan</td><td>20</td><td>-</td></tr><tr><td>2</td><td>utilization rate</td><td>10</td><td>-</td></tr></table>",
+        "bbox": [
+            221,
+            621,
+            773,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Job time and costs are most conflicting, while short processing times support a short makespan and tend to increase the utilization rate. Faster equipment typically is more expensive than slower, and the ratio between costs and duration of the use of equipment will play an important role. Thus, lower costs require the usage of equipment with a lower ratio of costs and duration. This tends to increase the duration and to decrease the workload of less cost-effective equipment. Additionally, shorter job times are also rewarded to some extent by the makespan and possibly by the utilization rate, but costs are not. These considerations are supported by the observation that the processing times are easier to reduce than costs. Thus, job time and costs should compete from the beginning and both should receive a larger portion of the weights. Therefore, they are grouped together at the highest priority so that they always contribute to the weighted sum, as shown in Table 1. As a rule of thumb, further objectives,",
+        "bbox": [
+            80,
+            734,
+            919,
+            934
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            80,
+            55,
+            238,
+            70
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "page_number",
+        "text": "175",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "which are less conflicting with each other and those of higher priorities, can go into the same group. After having determined the priority and grouping structure based on experience and considerations about the relationships between the objectives, appropriate weights and thresholds must be chosen.",
+        "bbox": [
+            80,
+            93,
+            917,
+            151
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Based on these considerations and a representative scheduling task, a schedule can be produced based on Pareto optimality for the identification of the region of interest, from which thresholds and weights can be derived. In the given example, this can be done in a first step for a reduced set of objectives by omitting a less conflicting one, e.g., the utilization rate. The Pareto fronts for good makespans of the two remaining objectives can be plotted. From it, the thresholds and the ratio of the weights between them can be derived, see Figure 2 for the relationship between Pareto front and the weights and Figure 5 for the usage of thresholds. This results in a ratio of 3:4 between the averaged job times and costs in the given example. The threshold values  $\\varepsilon_{i}$  are used as percentage values related to the available scale between  $\\min(f_i)$  and  $\\max(f_i)$ , as shown in Equation (8):",
+        "bbox": [
+            80,
+            154,
+            917,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nf _ {i, \\varepsilon} = \\min  \\left(f _ {i}\\right) + \\varepsilon_ {i} \\left(\\max  \\left(f _ {i}\\right) - \\min  \\left(f _ {i}\\right)\\right) \\tag {8}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            347,
+            341,
+            912,
+            360
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this case, the objectives of the next group are activated for schedules where the costs are below  $75\\%$  of their available scales on the average and the finishing times are below  $60\\%$  of their spendable time frames on the average. This approach can be repeated for the rest of the objectives or the remaining weights are assigned according to experience. For the given example, it was decided based on previous observations that about  $70\\%$  of the weight should go to the first two objectives and the rest should go mainly to the makespan, as its reduction tends to increase the utilization rate. Table 1 shows the resulting weights. The suitability of the settings can be verified by the generation of a Pareto optimal schedule using all objectives and the comparison with the results obtained when using the CWS instead. Depending on the task at hand and the first setting of weights and thresholds, this may result in an iterative refinement.",
+        "bbox": [
+            80,
+            372,
+            917,
+            571
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "To sum up, weights and thresholds are derived from experience and/or from previous estimations of the Pareto front of a representative task. In Section 4 we will discuss the range of meaningful applications of the CWS.",
+        "bbox": [
+            80,
+            574,
+            917,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3.4. The Effect of the CWS on the Search",
+        "text_level": 1,
+        "bbox": [
+            82,
+            649,
+            413,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The effect of the cascaded assessment on population-based search procedures like EAs, PSO or ACO is illustrated in Figure 6 for two objectives and the example of the feasible objective region used in Figure 2. Based on previous knowledge, the sources of which are discussed in Section 4.3, a region of interest is defined for every objective group and the weights are set accordingly. Additionally, threshold values  $\\varepsilon_{i}$  are defined for all objectives but those of the group with the lowest priority. Care must be taken for the accessibility of the region of interest being not affected by these thresholds. In the example of Figure 6, objective two has a higher priority than objective one and a threshold value  $\\varepsilon_{2}$ . In the beginning of the search, a quality gain can be achieved for upward moves only. For those solutions that have surpassed  $\\varepsilon_{2}$ , the result of the first objective is added according to the weights changing the average movement direction towards the tangent and the region of interest. If the search runs long enough to come more or less close to convergence, most solutions will be found in the region of interest. The best of them will be at the intersection of the tangent and the Pareto front or at least",
+        "bbox": [
+            80,
+            684,
+            919,
+            923
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "page_number",
+        "text": "176",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "close to it. Especially for EAs, which preserve genotypic diversity to some extent, good but suboptimal solutions close to the best one covering at least parts of the area of interest are very likely to be found. This means that a run is stopped when stagnation occurs over a longer period of time and not when the entire population has (nearly) converged.",
+        "bbox": [
+            75,
+            93,
+            917,
+            173
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc4466dbc4d4b1cde5c14e6ac3a6ad1de60037ecbe7155acc7a896c415e14c49.jpg",
+        "image_caption": [
+            "Figure 6. Cascaded weighted sum for  $k = 2$  and objective two having a higher priority than objective one. Thus, solutions in the hatched area are bettered according to  $f_{2}$  only and will find the largest quality gain in upward moves (red arrow). This changes, if  $\\varepsilon_{2}$  is exceeded and  $f_{1}$  starts to contribute to the resulting sum, as shown by the black arrows."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            329,
+            278,
+            668,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "An example of a Pareto front with a non-convex section is shown in Figure 7 using the objective region and the threshold value of Figure 5. As the part between F2 and the rightmost end of the Pareto front is quasi excluded, it is possible now to obtain solutions in the marked area of interest. This would not be the case for the original weighted sum. On the other hand, if the region of interest was located between the magenta dot and F2, most of the Pareto front would still be missed.",
+        "bbox": [
+            75,
+            506,
+            917,
+            605
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/1dbfe304cae12f98c4baf10cd2f1ca0452a93817e33d3f6c72e1477bc15bd78b.jpg",
+        "image_caption": [
+            "Figure 7. Cascaded weighted sum and region of interest for the example with a non-convex Pareto front given in Figure 5."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            671,
+            663,
+            878
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            240,
+            70
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "page_number",
+        "text": "177",
+        "bbox": [
+            882,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Normalization according to Equations (3) or (4) is done linearly with the same ratio for the entire interval  $[\\min(f_i), \\max(f_i)]$ . If previous knowledge is available for defining an area of interest for the Pareto front, corresponding subintervals are also known for the single objectives. This information can be used to tune the normalization function, as is shown exemplarily in Figure 8. More normalization functions can be found in [15].",
+        "bbox": [
+            75,
+            93,
+            917,
+            192
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/89768f1ec4562c6ae09740de3232f4a36b9f8c4dc34b67b5c287ee832d694a25.jpg",
+        "image_caption": [
+            "Figure 8. Tuning the normalization of Equation (3) (blue straight line) to the interval of interest of one objective  $f_{i}$ . The decline outside of this interval is reduced drastically to allow for a strong increase inside, as shown by the green graph."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            279,
+            779,
+            488
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3.5. Summary",
+        "text_level": 1,
+        "bbox": [
+            80,
+            506,
+            194,
+            523
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The grouping of the CWS reduces the amount of objectives considered at once and makes weighting easier. The CWS integrates objective thresholds comparable to those of the  $\\varepsilon$ -constrained method, which are easier to handle for experts in the application field than weights, which now play a relatively minor role. The CWS allows for obtaining parts of a non-convex Pareto front, which were unreachable for the original weighted sum. However, it is still possible that some of these parts remain unattainable. These arguments underline the superiority of the CWS over the pure weighted sum. All aggregation methods alone are not suited as a priori approaches, as they require some previous knowledge to be parameterized.",
+        "bbox": [
+            75,
+            539,
+            919,
+            700
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. Cascaded Weighted Sum and Its Field of Application",
+        "text_level": 1,
+        "bbox": [
+            77,
+            715,
+            559,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Optimization problems can be classified according to different criteria, such as the number of decision variables or of objectives, or the nature of the search space, where the number of (expected) suboptima or continuity plays an important role, or the type of project to which the optimization project belongs. The latter is often ignored in scientific literature, although it plays a significant role in real-world applications. Thus, we will take a closer look at that issue in the next sections. We will also consider the amount of objectives, as both properties are well suited to compare both assessment methods.",
+        "bbox": [
+            75,
+            750,
+            919,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "page_number",
+        "text": "178",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4.1. Number of Objectives",
+        "text_level": 1,
+        "bbox": [
+            80,
+            93,
+            294,
+            111
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As already discussed in Section 3.3 objectives can conflict more or less. We consider here only objectives, the decision maker regards as conflicting in the sense that they shall be part of Pareto optimality. The amount of these objectives plays an important role for the practical applicability of the Pareto method. The Pareto front of up to three objectives can be visualized easily. For up to four or five objectives, decision maps, polyhedral approximation, or other visualization techniques can be used, see [20]. Interactive visualization techniques may support perception for more than three objectives, \"but this requires more cognitive effort if the number of objectives increases\", as Lotov and Miettinen summarize their chapter on visualization of the Pareto frontier in [20]. Thus, we can conclude that from five and in particular from more criteria, the perception and the comprehension of the Pareto front become increasingly difficult and turn into a business for experienced experts.",
+        "bbox": [
+            80,
+            127,
+            919,
+            326
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0450b4aba2b2c319bfbc17b937ade1132c3fcb8c2077e942162cf78b7f215051.jpg",
+        "image_caption": [
+            "Figure 9. The number of required data points (Pareto-optimal solutions) of an approximation of a Pareto front increases exponentially with a growing number of conflicting objectives. The green line is based on a resolution of 7 data points per additional objective (axis), while the blue one uses 5 only."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            211,
+            435,
+            784,
+            694
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Another question is the effort to determine the Pareto front. For an acceptable visualization of the Pareto front, approximations like the one described in [21] may be used. Depending on the desired quality of approximation, a number of 5 to 7, in general  $s$ , Pareto-optimal solutions may be sufficient for two objectives. Assuming that the same quality of interpolation and granularity of support points shall be maintained when further objectives are added,  $s^{(k - 1)}$  support points are required for the interpolation of the hyperplane of the Pareto front, provided that all areas shall be examined. With interactive approaches, this can be reduced to some extent, but at the risk of missing promising regions. Figure 9 illustrates this growth of required Pareto optimal solutions. For 5 objectives, for example, 625 solutions are required to interpolate the entire hyperplane with 5 data points per axis. For a better interpolation quality obtained from 7 data points per axis 2401 solutions are needed. It should be noted that every data point requires several evaluations of solutions according to the optimization",
+        "bbox": [
+            80,
+            714,
+            919,
+            935
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            68
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "page_number",
+        "text": "179",
+        "bbox": [
+            884,
+            54,
+            915,
+            67
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "or approximation procedure used. Depending on the application, evaluations may be based on time-consuming simulations and last several seconds or minutes each. This clearly limits the practical applicability of the Pareto method for growing numbers of conflicting objectives. One solution is to reduce the number of objectives by an aggregation of less conflicting objectives to one.",
+        "bbox": [
+            80,
+            93,
+            917,
+            171
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4.2. Classification of Application Scenarios and Examples",
+        "text_level": 1,
+        "bbox": [
+            80,
+            189,
+            552,
+            206
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Optimization projects can be classified into three different types:",
+        "bbox": [
+            104,
+            223,
+            628,
+            240
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "I. The nonrecurring type, which is performed once with little or no prior knowledge of e.g., the impact and relevance of decision variables or the behavior of objectives. This type requires many decisions regarding e.g., the number and ranges of decision variables, the number and kind of objectives, of restrictions, and more.",
+            "II. The extended nonrecurring project, where some variants of the first optimization task are handled as well. Frequently, the modifications of the original project are motivated by the experience gained in the first optimization runs. As in the first type, decisions are usually made by humans.",
+            "III. The recurring type, usually based on experience gained from a predecessor project and frequently part of an automated process without or with minor human interaction only."
+        ],
+        "bbox": [
+            100,
+            250,
+            917,
+            450
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Examples of Types I and II are design optimization tasks like the design of micro-optical devices as described in [22] or problems from such a challenging field like aerodynamic design optimization, see e.g., [23]. A typical example of type III is the task of scheduling jobs to be processed on a computational grid as introduced in the last section and described in detail in [6]. Normally, nobody is interested in the details of the actual schedule, which usually will be replaced soon by a new one due to a replanning event like a new job to be planned or the introduction of new resources. Another example is the planning of collision-free paths for movements of industrial robots, as described in detail and for different industrial robot types in [14,15,24,25]. This example also shows that in some cases human judgment is possible in addition to a pure consideration of the achieved objective figures of a generated robot move path. The decision maker can take a look at the resulting movement using a robot simulator or the real device. Assessing this movement is much more impressive and illustrative than reading objective figures. On the other hand, such a well-fitting visualization is not always available.",
+        "bbox": [
+            80,
+            460,
+            917,
+            699
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4.3. Comparison of Pareto Optimization and CWS in Different Application Scenarios",
+        "text_level": 1,
+        "bbox": [
+            80,
+            715,
+            769,
+            733
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4.3.1. Individual Optimization Project",
+        "text_level": 1,
+        "bbox": [
+            80,
+            750,
+            389,
+            766
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For the first project type, the ranges of possibly achievable objective values usually are not known in advance. In this case, an estimation of them can be obtained from a Pareto optimization. From these data and the resulting Pareto front, a human decision maker can opt for additional and modified optimization or select the final solution. This type of optimization project clearly belongs to the domain of Pareto-based optimization.",
+        "bbox": [
+            80,
+            785,
+            917,
+            883
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            70
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "page_number",
+        "text": "180",
+        "bbox": [
+            884,
+            55,
+            915,
+            68
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4.3.2. Optimization Project with Some Task Variants",
+        "text_level": 1,
+        "bbox": [
+            77,
+            93,
+            512,
+            111
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In many cases, the above statement also applies to the second project type, as experience is still limited and there must be good reasons to change the assessment method. Such a reason may be more than five objectives and if one or few areas of interest can be identified. In such cases, the computational effort can be reduced significantly. As mentioned before, an assessment of one solution in real world applications is frequently done by a simulation run, the duration of which strongly depends on the application at hand. One simulation may require seconds or even minutes and more. In such cases, the reduction of the number of evaluations is critical and an early concentration on the area of interest by using the CWS can be essential for the success of the project. On the other hand, the impact of the optimization is another important and application-dependent issue: If the savings expected from optimization justify the computational effort, Pareto optimization should be used until the areas of interest are reliably identified. Based on that, these areas can be explored in greater detail by optimization runs using the CWS, as illustrated in Figure 10. These considerations show that according to the project conditions, both methods may complement each other.",
+        "bbox": [
+            75,
+            128,
+            922,
+            388
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f12a0652514fdf41070930abd560c4cb3e319f17d304332fb21977608bbf040.jpg",
+        "image_caption": [
+            "Figure 10. Both diagrams show a sample population of an advanced search more or less shortly before convergence. The CWS concentrates the best individuals (black dots) more or less on the region of interest, as shown in the left diagram. In contrast to that, Pareto-based optimization procedures attempt to distribute their solutions along the Pareto front as best as they can, see the right diagram. Thus, fewer solutions will be found in the area of interest."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            154,
+            535,
+            845,
+            741
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "4.3.3. Repeated Optimization, also as Part of an Automated Process",
+        "text_level": 1,
+        "bbox": [
+            77,
+            760,
+            631,
+            778
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Another domain of CWS-based optimization or planning is project type III, where the same task is executed repeatedly with minor modifications and, thus, known areas of interest. If a major change occurs, the area of interest can be adapted by using Pareto optimization. A typical example is the scheduling of jobs to the heterogeneous resources of a computational grid, as was introduced before and described in detail in [6]. It is a permanent replanning process, because events demanding a change of the schedule may occur long before a plan is completed. Examples are the introduction of new jobs or new resources, unexpected deactivations of resources, changes of the cost profiles of",
+        "bbox": [
+            75,
+            796,
+            922,
+            936
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            240,
+            70
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "page_number",
+        "text": "181",
+        "bbox": [
+            884,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "resources, early completion of jobs, or the like. As described in [6], five objectives are optimized and four penalty functions are used to handle the restrictions. Because planning time is limited and thousands of jobs and hundreds of resources must be handled, the planning must be stopped (long) before the used Evolutionary Algorithm converges. Thus, it is important to explore the region of interest as well as possible, see Figure 10. Additionally, there is no human expert to check the results several times per hour. For this automated scheduling process, the determination of the Pareto front makes no sense and the CWS is a meaningful alternative. These considerations also apply to many other scheduling tasks like the one described in [15,19].",
+        "bbox": [
+            80,
+            93,
+            917,
+            252
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Another example already mentioned is the planning of collision-free movement paths for an industrial robot [14,15,24,25]. Depending on the task at hand, we have four or five objectives and at the minimum one penalty function to handle collisions. As robot movements can be simulated and visualized, the results are checked by a human expert mostly on the level of robot movements rather than of objective figures. As areas of interest usually are also known in advance and new solutions should be generated fast, the CWS is suited here as well and for the same reasons as with the task before.",
+        "bbox": [
+            80,
+            255,
+            917,
+            373
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "5. Conclusions",
+        "text_level": 1,
+        "bbox": [
+            82,
+            390,
+            206,
+            407
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Section 4.1 it was shown that the amount of solutions required to approximate a Pareto front increases exponentially with a growing number of conflicting objectives. As illustrated in Figure 9, the amount of evaluations increases considerably for more than five objectives. This limits the applicability of the Pareto approach for real-world applications, which frequently require time-consuming evaluations especially when based on simulation.",
+        "bbox": [
+            80,
+            425,
+            917,
+            523
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We have introduced the cascaded weighted sum (CWS), which can be described roughly as a combination of the weighted sum and the  $\\varepsilon$ -constrained method. The major drawback of the pure weighted sum, the inaccessibility of parts of the Pareto front in non-convex cases, can be reduced to some extent by the CWS, see Section 3 and Figure 7. As the pure weighted sum, the CWS is not an a priori method. The major advantage of the CWS is its ability to concentrate solutions on the region of interest with less computational effort than Pareto optimization. In addition, this effort difference increases immensely with an increasing number of objectives, in particular for more than five. The region of interest can be a result of previous experience or knowledge, of a first Pareto-based optimization, or a combination thereof.",
+        "bbox": [
+            80,
+            526,
+            917,
+            703
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Section 4.2, optimization projects were divided into three types, the individual project type, projects treating some variants of the task, and the type of repeated optimization of the same task with more or less small variations. The unquestioned domain of Pareto optimization is the first type of optimization projects. For the second type and five or more objectives, a combination of both methods can be advantageous as was described in Section 4.3.2. For the third project type of repeated optimization of task variants and with no or only minor human interaction, the Pareto front is not required, as the regions of interest are already known from previous solutions or initial Pareto optimization. The concentration of the CWS on that region is beneficial, as the computational effort can be reduced significantly. This is of importance especially in those cases, where a fast solution is required or the amount of evaluations is limited due to long run times.",
+        "bbox": [
+            80,
+            708,
+            917,
+            906
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            80,
+            55,
+            238,
+            68
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "page_number",
+        "text": "182",
+        "bbox": [
+            885,
+            55,
+            915,
+            68
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Thus, we can conclude that both methods have their place and their field of application. Additionally, they can complement each other.",
+        "bbox": [
+            80,
+            93,
+            915,
+            130
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments",
+        "text_level": 1,
+        "bbox": [
+            80,
+            148,
+            240,
+            165
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "We acknowledge support by the Deutsche Forschungsgemeinschaft and Open Access Publishing Fund of Karlsruhe Institute of Technology.",
+        "bbox": [
+            80,
+            181,
+            915,
+            219
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Conflicts of Interest",
+        "text_level": 1,
+        "bbox": [
+            80,
+            237,
+            253,
+            253
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "The authors declare no conflict of interest.",
+        "bbox": [
+            104,
+            271,
+            448,
+            288
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            80,
+            306,
+            176,
+            322
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "1. Pareto, V. Cours d'Économie Politique, (in French); F. Rouge: Lausanne, Switzerland, 1896.",
+            "2. Hoffmeister, F.; Bäck, T. Genetic Algorithms and Evolution Strategies: Similarities and Differences; Technical Report SYS-1/92; FB Informatik, University of Dortmund: Dortmund, Germany, 1992.",
+            "3. Multiobjective Optimization: Interactive and Evolutionary Approaches; Lecture notes in computer science 5252; Branke, J., Deb, K., Miettinen, K., Sławinski, R., Eds.; Springer: Berlin, Germany, 2008.",
+            "4. Deb, K. Introduction to evolutionary multiobjective optimization. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Slosinski, R., Eds.; Lecture notes in computer science 5252; Springer: Berlin, Germany, 2008; pp. 58-96.",
+            "5. Miettinen, K. Nonlinear Multiobjective Optimization; International series in operations research & management science 12; Kluwer Academic Publishers: Boston, MA, USA, 1999.",
+            "6. Jakob, W.; Strack, S.; Quinte, A.; Bengel, G.; Stucky, K.-U.; Süß, W. Fast rescheduling of multiple workflows to constrained heterogeneous resources using multi-criteria memetic computing. Algorithms 2013, 2, 245-277.",
+            "7. Haimes, Y.Y.; Lasdon, L.S.; Wismer, D.A. On a bicriterion formulation of the problems of integrated system identification and system optimization. IEEE Trans. Syst. Man Cybern. 1971, 3, 296-297.",
+            "8. Osyczka, A. Multicriterion Optimization in Engineering with FORTRAN Programs; Ellis Horwood series in mechanical engineering; E. Horwood: London, UK, 1984.",
+            "9. Miettinen, K. Introduction to multiobjective optimization: Noninteractive approaches. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Słowyński, R., Eds.; Lecture notes in computer science 5252; Springer: Berlin, Germany, 2008; pp. 1-26.",
+            "10. Deb, K.; Pratap, A.; Agarwal, S.; Meyarivan, T. A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE Trans. Evol. Comput. 2002, 2, 182-197.",
+            "11. Zitzler, E.; Laumanns, M.; Thiele, L. SPEA2: Improving the strength pareto evolutionary algorithm for multiobjective optimization. In Evolutionary Methods for Design Optimization and Control with Applications to Industrial Problems, Proceedings of the EUROGEN'2001 Conference, Athens, Greece, 19-21 September 2001; Giannakoglou, K.C., Tsahalis, D.T., Périaux,"
+        ],
+        "bbox": [
+            78,
+            340,
+            922,
+            923
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            238,
+            71
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "page_number",
+        "text": "183",
+        "bbox": [
+            882,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "J., Papailiou, K.D., Fogarty, T., Eds.; International Center for Numerical Methods in Engineering: Athens, Greece: 2001; pp. 95-100.",
+            "12. Beume, N.; Naujoks, B.; Emmerich, M. SMS-EMOA: Multiobjective selection based on dominated hypervolume. Eur. J. Oper. Res. 2007, 3, 1653–1669.",
+            "13. Blume, C. GLEAM—A system for simulated \"intuitive learning\". In Parallel Problem Solving from Nature: Proceedings of the 1st Workshop, Dortmund, Germany, 1-3 October 1990; Schwefel, H.-P., Manner, R., Eds.; Lecture notes in computer science 496; Springer: Berlin, Germany, 1991; pp. 48-54.",
+            "14. Blume, C.; Jakob, W.; Krisch, S. Robot trajectory planning with collision avoidance using genetic algorithms and simulation. In Proceedings of the 25th International Symposium on Industrial Robots (ISIR), Hanover, Germany, 25-27 April, 1994; pp. 169-175.",
+            "15. Blume, C.; Jakob, W. GLEAM—General Learning Evolutionary Algorithm and Method. Ein evolutionärer Algorithmus und seine Anwendungen, (in German); Schriftenreihe des Instituts für Angewandte Informatik, Automatisierungstechnik am Karlsruhe Institut für Technologie 32; KIT Scientific Publishing: Karlsruhe, Germany, 2009.",
+            "16. Gorges-Schleuter, M. Explicit parallelism of genetic algorithms through population structures. In Proceedings of the 1st Workshop on Parallel Problem Solving from Nature (PPSN I), Dortmund, Germany, 1-3 October 1990; Schwefel, H.-P., Manner, R., Eds.; LNCS 496, Springer: Berlin, Germany, 1991; pp. 150-159.",
+            "17. Sarma, K.; de Jong, K. An analysis of the effects of neighborhood size and shape on local selection algorithms. In Proceedings of the 4th International Conference on Parallel Problem Solving from Nature (PPSN IV), LNCS 1141, Berlin, Germany, 22-26 September 1996; Voigt, H.-M., Ebeling, W., Rechenberg, I., Schwefel, H.-P., Eds.; Springer: Berlin, Germany, 1996; pp. 236-244.",
+            "18. Nguyen, Q.H.; Ong, Y.-S.; Lim, M.H.; Krasnogor, N. Adaptive cellular memetic algorithms. Evol. Comput. 2009, 17, 231-256.",
+            "19. Jakob, W. A general cost-benefit-based adaptation framework for multimeme algorithms. Memet. Comput. 2010, 3, 201-218.",
+            "20. Lotov, A.V.; Miettinen, K. Visualizing the Pareto Frontier. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Słowyński, R., Eds.; Lecture notes in computer science 5252; Springer: Berlin, Germany, 2008; pp. 213-243.",
+            "21. Klamroth, K.; Tind, J.; Wiecek, M.M. Unbiased approximation in multicriteria optimization. Math. Method Oper. Res. 2003, 3, 413-437.",
+            "22. Jakob, W.; Gorges-Schleuter, M.; Sieber, I.; Suß, W.; Eggert, H. Solving a highly multi-modal design optimization problem using the extended genetic algorithm GLEAM. In Computer Aided Optimum Design of Structures VI: Conf. Proc. OPTI 99; Hernandez, S., Kassab, A.J., Brebbia, C.A., Eds.; WIT Press: Southampton, UK, 1999; pp. 205-214."
+        ],
+        "bbox": [
+            80,
+            92,
+            919,
+            839
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            240,
+            71
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "page_number",
+        "text": "184",
+        "bbox": [
+            882,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "23. Stewart, T.; Bandte, O.; Braun, H.; Chakraborti, N.; Ehrgott, M.; Göbelt, M.; Jin, Y.; Nakayama, H.; Poles, S.; di Stefano, D. Real-world applications of multiobjective optimization. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Słowyński, R., Eds.; Lecture notes in computer science 5252; Springer-Verlag: Berlin, Germany, 2008; pp. 285-327.",
+            "24. Blume, C. Automatic Generation of Collision Free Moves for the ABB Industrial Robot Control. In Proceedings of the 1997 First International Conference on Knowledge-Based Intelligent Electronic Systems (KES '97), Adelaide, SA, Australia, 21-23 May 1997; Volume 2, pp. 672-683.",
+            "25. Blume, C. Optimized Collision Free Robot Move Statement Generation by the Evolutionary Software GLEAM. In Real World Applications of Evolutionary Computing: Proceedings; Cagnoni, S., Ed.; Lecture notes in computer science 1803; Springer: Berlin, Germany, 2000; pp. 327-338.",
+            "© 2014 by the authors; licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution license (http://creativecommons.org/licenses/by/3.0/)."
+        ],
+        "bbox": [
+            78,
+            93,
+            917,
+            409
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "header",
+        "text": "Algorithms 2014, 7",
+        "bbox": [
+            78,
+            54,
+            240,
+            71
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "page_number",
+        "text": "185",
+        "bbox": [
+            882,
+            54,
+            915,
+            68
+        ],
+        "page_idx": 19
+    }
+]

2203.02xxx/2203.02697/9f953933-84bb-40cc-b218-d16d7f5c68c3_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:528663c9747a0fc44acc11a2bd1b9fbb62c598024f91f821ac781615a9f325bc
+size 546361

2203.02xxx/2203.02697/full.md

@@ -0,0 +1,307 @@
+# Pareto Optimization or Cascaded Weighted Sum: A Comparison of Concepts
+
+Wilfried Jakob  $^{1, *}$  and Christian Blume
+
+$^{1}$  Karlsruhe Institute of Technology (KIT), Institute of Applied Computer Science (IAI), P.O. Box 3640, Karlsruhe 76021, Germany  
+$^{2}$  Cologne University of Applied Sciences, Institute of Automation and Industrial IT, Steinmüllerallee 1, Gummersbach 51643, Germany; E-Mail: blume@gm.fh-koeln.de  
+* Author to whom correspondence should be addressed; E-Mail: wilfried.jakob@kit.edu; Tel.: +49-721-608-24663; Fax: +49-721-608-22602.
+
+Received: 22 January 2014; in revised form: 3 March 2014 / Accepted: 14 March 2014 /
+
+Published: 21 March 2014
+
+Abstract: Looking at articles or conference papers published since the turn of the century, Pareto optimization is the dominating assessment method for multi-objective nonlinear optimization problems. However, is it always the method of choice for real-world applications, where either more than four objectives have to be considered, or the same type of task is repeated again and again with only minor modifications, in an automated optimization or planning process? This paper presents a classification of application scenarios and compares the Pareto approach with an extended version of the weighted sum, called cascaded weighted sum, for the different scenarios. Its range of application within the field of multi-objective optimization is discussed as well as its strengths and weaknesses.
+
+Keywords: multi-criteria optimization; Pareto optimization; weighted sum; cascaded weighted sum; global optimization; population based optimization; evolutionary algorithm
+
+# 1. Introduction
+
+Most nonlinear real-world optimization problems require the optimization of several objectives and usually at least some of them are contradictory. A simple example of two conflicting criteria is the payload and the traveling distance with a given amount of fuel, which cannot be maximized both at the same time. The typical solution of such a problem is a compromise. A good compromise is one
+
+where one of the criteria can be improved only by worsening at least one of the others. This approach is called Pareto optimization [1], and the set of all good compromises is called Pareto optimal solutions or non-dominated solutions. In practice, usually only one solution is required. Thus, multi-objective optimization based on Pareto optimality is divided into two phases: At first, the set of Pareto optimal solutions is determined, out of which one must be chosen as the final result by a human decision maker according to more or less subjective preferences. This is in contrast to single-objective optimization tasks, where no second selection step is required.
+
+Most population-based search procedures, like evolutionary algorithms, particle swarm or ant colony optimization, require a single quality value called e.g., fitness in the context of evolutionary algorithms. This may be one reason for the frequent aggregation of different optimization criteria to a single quality value. Two methods, the frequently used weighted sum and the  $\varepsilon$ -constrained method, are described briefly. Another commonly used method is to express everything in costs. On closer inspection, it becomes apparent that this is equal to the weighted sum approach using suitable weights. Additionally, the conversion into costs requires an artificial redefinition of the original goals and this is often not really appropriate. Thus, most multi-objective optimization problems have meanwhile been solved based on Pareto optimization, at least in academia.
+
+The computational effort to determine all or at least most of the Pareto front increases significantly with the number of conflicting objectives, as will be shown later in the paper. However, what if the complete Pareto front is not needed at all, because the area of interest is already known? In this paper we will introduce an aggregation method called the cascaded weighted sum (CWS) and discuss application scenarios, where aggregation methods like the CWS can compete with Pareto-optimality-based approaches. Not to be misunderstood: We agree that in many fields of application, Pareto optimization is the appropriate method for multi-objective problems. Although we will concentrate on evolutionary multi-objective optimization later in the paper, the issues discussed here can be applied to other global optimization procedures as well and especially to those, which optimize a set of solutions simultaneously instead of just one.
+
+The paper is organized as follows: In Section 2 the basics of Pareto optimization are described, followed by the weighted sum and the  $\varepsilon$ -constrained method, including a brief discussion of their properties. In Section 3, the cascaded weighted sum is introduced. Section 4 starts with a classification of application scenarios, gives some examples, and discusses the question for which scenario which method is suited better or how they can complement each other. The paper closes in Section 5 with a summary and a conclusion.
+
+# 2. Short Introduction to Pareto Optimization and Two Aggregation Methods
+
+Based on Hoffmeister and Bäck [2], and the notation of Branke et al. [3], a multi-objective optimization problem is the task of maximizing a set of  $k (>1)$  usually conflicting objective functions  $f_{i}$  simultaneously, denoted by maximize  $\{...\}$ :
+
+$$
+\begin{array}{l} \text {m a x i m i z e} \left\{f _ {1} (x), f _ {2} (x), \dots , f _ {k} (x) \right\}, x \in S \\ f _ {i}: S \subseteq S _ {1} \times \dots \times S _ {n} \rightarrow \Re , S \neq \emptyset \tag {1} \\ \end{array}
+$$
+
+The focus on maximization is without loss of generality, because  $\min \{f(x)\} = -\max \{-f(x)\}$ . The nonempty set  $S$  is called the feasible region and a member of it is called a decision (variable) vector  $x = (x_{1}, x_{2}, \ldots, x_{n})^{T}$ . As it is of no further interest here, we do not describe the constraints forming  $S$  in more detail. Frequently, the  $S_{i}$  are the set of real or whole numbers or a subset thereof, but they can be any arbitrary set as well. Objective vectors are images of decision vectors, consisting of objective (function) values  $z = f(x) = (f_{1}(x), f_{2}(x), \ldots, f_{k}(x))^{T}$ . Accordingly, the image of the feasible region in the objective space is called the feasible objective region  $Z = f(S)$ . Figure 1 illustrates this.
+
+![](images/0235fe3a5ca0707d49866992d60c0adb72dc14f557ef17efa0789b8ea11194b5.jpg)  
+Figure 1. Feasible region  $S$  and its image, the feasible objective region  $Z$  for  $n = k = 2$ . The set of weakly Pareto optimal solutions is shown as a bold green line in the diagram on the right. The subset of Pareto optimal solutions is the part of the green line between the black circles. The ideal objective vector  $z^*$  consists of the upper bounds of the Pareto set.
+
+In the following sections Pareto optimization and two frequently used aggregation methods, which turn a multi-objective problem into a single-objective task, are introduced and compared in the end.
+
+# 2.1. Pareto Optimization
+
+A decision vector  $x \in S$  dominates another vector  $y \in S$ , if
+
+$$
+\begin{array}{l} \forall i \in \{1, 2, \dots , k \}: f _ {i} (x) \geq f _ {i} (y) a n d \\ \exists j \in \{1, 2, \dots , k \}: f _ {j} (x) > f _ {j} (y) \tag {2} \\ \end{array}
+$$
+
+A decision vector  $x' \in S$ , which is not dominated by any other  $x \in S$ , is called Pareto optimal. The objective vector  $z' = f(x')$  is Pareto optimal, if the corresponding decision vector is Pareto optimal and the corresponding sets can be denoted by  $P(S)$  and  $P(Z)$ . The set of weakly Pareto optimal solutions, which is a superset of the set of Pareto optimal solutions, is formed by decision vectors, for which the following applies: An  $x' \in S$  is called weakly Pareto optimal, if no other  $x \in S$  exists such that  $f_i(x) > f_i(x')$  for all  $i = 1, \ldots, k$ . As the set of Pareto optimal solutions consists of decision vectors only, which are not dominated, they can be regarded as the set of good compromises mentioned in the introduction. It follows from the definition that they are located on the border of the feasible objective region, as shown in the right part of Figure 1. The figure also illustrates the concept of weakly Pareto optimal solutions lying on the part of the green line outside of the section bounded by the black circles
+
+in the given example. It should be stated that the set of Pareto optimal solutions does not need to be as nicely shaped as shown in Figure 1; it may also be non-convex and disconnected.
+
+The upper bounds of the Pareto optimal set can be obtained by maximizing the  $f_{i}$  individually with respect to the feasible region. This results in the ideal objective vector  $z^{*}\in \Re^{k}$ , an example of which is shown for the two-dimensional case in the right part of Figure 1. The lower bounds are usually hard to determine, see [3]. Although Pareto-based search methods can provide valuable estimations of the ranges of the objectives for practical applications, they are not suited for an exact determination of their lower and upper bounds.
+
+According to [4], constraints in the objective space are handled as follows: A solution  $x$  constrained-dominates a solution  $y$ , if any of the three conditions is satisfied:
+
+- Solution  $x$  is feasible and  $y$  is not.  
+- Both solutions are feasible and  $x$  dominates  $y$ .  
+- Both solutions are infeasible, but  $x$  has a smaller constrained violation than  $y$ . If more than one constraint is violated, the violations are normalized, summed up, and compared.
+
+Hereinafter, the term Pareto optimization is used for an optimization procedure employing Pareto optimality to assess and compare generated solutions.
+
+# 2.2. Weighted Sum
+
+One of the probably most often used assessment methods besides Pareto optimality is the weighted sum, which aggregates the objective values to a single quality measure. As the objective functions frequently have different scales, they are usually normalized. This can be done for example by using Equations (3) or (4) when minimizing and maximizing the objectives, respectively:
+
+$$
+f _ {i} ^ {\text {n o r m}} = \frac {\max \left(f _ {i}\right) - f _ {i}}{\max \left(f _ {i}\right) - \min \left(f _ {i}\right)} \text {f o r o b j e c t i v e s t o b e m i n i m i z e d} \tag {3}
+$$
+
+$$
+f _ {i} ^ {\text {n o r m}} = 1 - \frac {\max \left(f _ {i}\right) - f _ {i}}{\max \left(f _ {i}\right) - \min \left(f _ {i}\right)} \text {f o r o b j e c t i v e s t o b e m a x i m i z e d} \tag {4}
+$$
+
+The bounds of the objective function  $fi$  can be estimated or are the result of a maximization of each function individually in case of  $\max(f_i)$ . For the calculation of the weighted sum as shown in Equation (5), a weight  $w_i$  has to be chosen for every objective:
+
+$$
+\text {m a x i m i z e} \sum_ {i = 1} ^ {k} w _ {i} f _ {i} ^ {\text {n o r m}} (x), \quad x \in S \text {w h e r e} w _ {i} > 0 \text {f o r a l l} i = 1, \dots , k \text {a n d} \sum_ {i = 1} ^ {k} w _ {i} = 1 \tag {5}
+$$
+
+By varying the weights, any point of a convex Pareto front can be obtained. Figure 2 illustrates this: The straight line corresponding to the chosen weights  $w_{1}$  and  $w_{2}$  is moved towards the border of the feasible objective region during the optimization process and becomes a tangent in point P. The solutions found are Pareto optimal, see [5].
+
+On the other hand, it is possible that parts of the Pareto front cannot be found in case of a non-convex problem. This is illustrated in Figure 3: the part between points A and B of the Pareto front cannot be obtained for any weights. This is a serious drawback.
+
+![](images/b4f9e3bf301ec55325cc194f2ba779a15611d8fe6a771daa5b8d4fd1469e3ddf.jpg)  
+Figure 2. By using appropriate weights, every point of a convex Pareto front can be achieved by the weighted sum. Here, point  $\mathbf{P}$  can be obtained for the weights  $w_{1}$  and  $w_{2}$ . The arrows show the movement direction of points where the largest quality gain is obtained.
+
+![](images/6bab592db324588f3c9cf05c876c9f1d43677f1a32cd1ee911d349aad6f40dfe.jpg)  
+Figure 3. For non-convex Pareto fronts, it is possible that parts of the front can not be obtained by the weighted sum. The region between points  $\mathbf{A}$  and  $\mathbf{B}$  is an example of this serious draw back of this aggregation method.
+
+As mentioned above, the weighted sum is often used for practical applications. Reasons are the simplicity of its application and the easy way to integrate restrictions, which are beyond pure limitations of the feasible region. Examples are scheduling tasks, where the jobs to be scheduled have due dates for finalization. Thus, delays can occur and it is not sufficient to tell the search procedure that this constrained violation is an infeasible solution by e.g., rejecting it. Instead, the search must be guided out of the infeasible region by rewarding a reduction of the violation. In the example given, this can be done by counting the number of jobs involved and summing up the amounts of delays, see e.g., [6]. These two key figures can either become new objectives or can be treated as penalty functions. As they do not represent wanted properties and as a low number of objectives is preferable, penalty functions are the method of choice. They can be designed to yield values between zero (maximal violation) and one (no violation). The results of all penalty functions serve as factors by which the weighted sum is multiplied. As a result, the pure weighted sum turns into a raw quality measure, which represents the solution quality of the problem without constraints, while the final
+
+product represents the solution for the task with its constraints. Figure 4 shows a typical example of such a penalty function. If the maximum value of constraint violation is hard to predict, as it is often the case, an exponential function can be chosen. A value of delay  $dp$  for poor solutions can usually be estimated roughly and the exponential function is attributed such that it yields a value of  $\frac{1}{3}$  in this case.
+
+![](images/ab2a667072480f1ad928a31d483490be74c166aa2075ce68a412d48af4ca7f27.jpg)  
+Figure 4. Example of a penalty function. It turns constraint violations into a penalty value between 1 and 0, which serves as a factor for decreasing the weighted sum.
+
+# 2.3.  $\varepsilon$ -Constrained Method
+
+The  $\varepsilon$ -constrained method is based on the optimization of one selected objective function  $f_{j}$  and treating the others as constraints [7]. The optimization problem now has the form
+
+$$
+\begin{array}{l} \text {m a x i m i z e} f _ {j} (x), \quad x \in S, \quad j \in \{1, \dots , k \} \\ f _ {i} (x) \geq \varepsilon_ {i} \text {f o r a l l} i = 1, \dots , k, i \neq j \tag {6} \\ \end{array}
+$$
+
+The  $\varepsilon_{j}$  are the lower bounds for those objective functions that are treated as constraints. For practical applications, the appropriate bounds must be selected carefully. In particular, it must be ensured that the bounds are within the feasible objective region, because otherwise the resulting problem would have no solutions. Ośczyka gives suggestions for a systematic selection of values for the  $\varepsilon_{j}$  and illustrates them with sample applications [8].
+
+Figure 5 gives an example based on the feasible region shown in Figure 3. In Figure  $5f_{2}$  is treated as a constraint with the lower bound  $\varepsilon_{2}$ . Thus, the remaining Pareto front is the section between the points F1 and F2. The figure also shows the main movement direction of solutions in  $Z$  that have exceeded the threshold  $\varepsilon_{2}$ . The main movement direction results from the optimization. Move components up- and downwards are also possible, but are not considered by the assessment procedure of this method as long as they do not drop below  $\varepsilon_{2}$ . A too large value of the constraint like  $\varepsilon_{bad}$  would make the problem unsolvable.
+
+A decision vector  $x' \in S$  is Pareto-optimal, if and only if it solves Equation (6) for every  $j = 1, \dots, k$ , where  $\varepsilon_i = f_i(x')$  for  $i = 1, \dots, k, i \neq j$ , see [9]. This means that  $k$  different problems must be solved for every member of the Pareto front, which can be expected to be computationally costly. If the task can be relaxed to weak Pareto optimality, only one solution of Equation (6) per member of
+
+the front is required [9]. On the other hand, the method does not require convexity for finding any Pareto-optimal solution.
+
+![](images/50165a7bfbef8f28979176d94d7757146949ad85567743afeac10e6955a98b83.jpg)  
+Figure 5. Restricted objective region using the  $\varepsilon$ -constrained method. The hatched region is excluded due to the lower bound  $\varepsilon_{2}$ . The remaining Pareto front is limited by F1 and F2. For too large bounds like  $\varepsilon_{bad}$ , the problem becomes unsolvable.
+
+# 2.4. Summary
+
+The two aggregation procedures (More aggregation methods can be found in [9].) can both find any Pareto-optimal solution for convex problems and the  $\varepsilon$ -constrained method can do that for non-convex tasks, too. This advantage of the  $\varepsilon$ -constrained method goes at the expense of higher computational costs: For finding a Pareto-optimal solution, the  $\varepsilon$ -constrained method needs to solve  $k$  different problems, whereas the weighted sum needs to solve just one per element of the Pareto set.
+
+Another important issue is the manageability. Depending on the problem, it can be assumed that it is easier for experts in the application area to estimate lower bounds for objectives than weights, which are more abstract. Experts are usually familiar with objective values and they are intelligible for them as such.
+
+For optimization procedures working with a set of solutions, frequently called population, like Evolutionary Algorithms (EAs), Ant Colony (ACO) or Particle Swarm Optimization (PSO), or the like, the advantage for multi-objective optimization is the ability to determine, in principle, the entire Pareto front at once. Of course, an optimization procedure must be adapted such that it spreads the population to the Pareto front as best as possible instead of concentrating on some areas of it. Examples of such adapted procedures in the EA field are the non-dominated sorting Genetic Algorithm (NSGA-II) [10], the Strength Pareto EA (SPEA-2) [11], or the S-metric selection evolutionary multi-objective optimization algorithm (SMS-EMOA) [12], to mention only a few. These combinations of population-based optimization procedures and Pareto optimality in general will estimate the Pareto front roughly at the minimum, with less computational effort than it can be done using the aggregation methods introduced for the assessment of the individuals of the same population-based methods. In the latter case, about as many runs would be required as solutions should occupy the Pareto front. Thus, these algorithms specialized for finding as much of the Pareto front as possible in one run are the
+
+methods of choice for new problems, where little is known in advance and where a human decision maker is available to make the final choice.
+
+# 3. Cascaded Weighted Sum
+
+We have been using this extended version of the weighted sum since the inception of our Evolutionary Algorithm GLEAM (General Learning and Evolutionary Algorithm and Method) in 1990 [13], as we considered this assessment method a convenient way to steer the evolutionary search process for evolving improved collision-free robot move trajectories [13,14]. As we did not regard it as something special, we did not publish it in English (A detailed description in German of the cascaded weighted sum and all variants of the application of GLEAM to industrial robot path planning for several industrial robots can be found in [15]). until comments of reviewers of other publications on GLEAM changed our mind and revealed the need for a general discussion. Some impacts of the robot application on the evaluation of solutions are discussed later in Sections 4.2 and 4.3.3. Before the cascaded weighted sum is described, we will shortly introduce Evolutionary Algorithms and GLEAM in particular to the extent necessary for a better understanding of the following sections.
+
+# 3.1. Short Introduction to Evolutionary Algorithms and GLEAM
+
+Evolutionary Algorithms (EA) typically conduct a search in the feasible region, with this search being guided by a quality function usually called fitness function. The search is done in parallel by a set of solution candidates, called individuals, forming a population. If an individual is outside of the feasible region, it will be guided back by one or more penalty functions or comparable techniques. The fitness function may be one of the aggregation methods described above. Alternatively, it is guided by Pareto optimality and is therefore based on the amount of dominated solutions and possibly some other measure, which rewards a good spread of the non-dominated solutions along the Pareto front, see e.g., [10,12]. New solutions are generated by stochastic algorithmic counterparts of the two biological archetypes mutation and recombination, for which an individual selects a partner frequently influenced by the fitness. Thus, the generated offspring inherits properties from both parents. The third principle of evolution, the survival of the fittest, occurs when deciding about who is included in the next iteration. In elitist forms of EAs, the best individual survives always and therefore, the quality of the population can increase only. On the other hand, convergence cannot be ensured within limited time. To avoid premature convergence, various attempts have been made to maintain genotypic diversity for a longer period of time by establishing niches within the population, see e.g., [16-18]. GLEAM uses one of these methods [16] (An actual description of the diffusion model and its integration into GLEAM can be found in [19].) and, thus, frequently yields some distinct solutions of more or less comparable quality. Iterative, stochastic, and population-based optimization procedures in general tend to produce some variants of the best solution. How much they differ in properties and quality depends on the algorithm, the actions taken for maintaining diversity, and the length of the run.
+
+# 3.2. Definition of the Cascaded Weighted Sum
+
+In the cascaded weighted sum (CWS) each objective is assigned a weight  $w_{i}$  as with the pure weighted sum and a priority starting with 1 as the highest one. If desired, some objectives may have the same priority. All objectives but those with the lowest priority receive a user-given threshold  $\varepsilon_{i}$ . In the beginning, only the objectives of the highest priority are active and contribute to the weighted sum. The others are activated according to the following priority rule:
+
+If all objectives with the same priority exceed their threshold, the objectives of the next lower priority are activated and their values are added to the sum.
+
+As the objectives are grouped by the priorities and the groups are considered one after the other, the method is called cascaded weighted sum. A group whose members exceed their threshold is called a satisfied group. If at least one objective of a satisfied group drops below its threshold, the group is not satisfied anymore and consequently, all groups with lower priorities are deactivated, which will significantly reduce the resulting weighted sum.
+
+For the formal definition of the CWS given in Equation (7), the original  $f_{i}(x)$  are used for the threshold value checks rather than their normalized counterparts, as we assume that this is more convenient for experts of the application. The  $k$  objectives are sorted according to their priorities and we have  $g$  objective groups, where  $1 < g \leq k$ . For  $g = 1$ , the CWS would be identical with the weighted sum. Each group consists of  $m_{j}$  objectives, the sum of which is  $k$ . As with the original weighted sum, each  $w_{i} > 0$  and  $\sum_{i=1}^{k} w_{i} = 1$ .
+
+As there are differences for the first and the last priority group, Equation (7) shows the objectives contributing to the weighted sum for the highest priority 1, the general case of priority  $j$ , and the lowest priority  $g$ .
+
+Priority 1: if not all  $f_{i}(x) \geq \varepsilon_{i} \forall i = 1, \ldots, m_{1}$
+
+(highest priority) maximize  $\sum_{i = 1}^{m}w_{i}f_{i}^{\text{norm}}(x), x\in S, m = m_{1}$
+
+Priority  $j$  : if all  $f_{i}(x)\geq \varepsilon_{i}\quad \forall i = 1,\ldots ,l_{j}$  and  $l_{j} = \sum_{l = 1}^{j - 1}m_{l}$  (satisfied groups)
+
+not all  $f_{i}(x)\geq \varepsilon_{i}\quad \forall i = l_{j} + 1,\ldots ,l_{j} + m_{j}$  maximize  $\sum_{i = 1}^{m}w_{i}f_{i}^{\mathrm{norm}}(x),\quad x\in S,\quad m = l_{j} + m_{j}$  (7)
+
+Priority  $g$  : if all  $f_{i}(x)\geq \varepsilon_{i}\quad \forall i = 1,\ldots ,l_{g},\quad l_{g} = \sum_{l = 1}^{g - 1}m_{l}$  (satisfied groups) (lowest priority)
+
+$$
+\text {m a x i m i z e} \sum_ {i = 1} ^ {k} w _ {i} f _ {i} ^ {\text {n o r m}} (x), x \in S
+$$
+
+Once a group is satisfied, the total quality value is increased abruptly by the values from the next activated group, which they can lose, if only one objective of a group with higher priority undergoes its  $\varepsilon_{i}$ . This makes it very unlikely for more successful solutions that the once gained values of the already contributing objectives drop below their thresholds in the course of further search.
+
+The selection of appropriate weights and threshold values requires some knowledge about the problem at hand, including one or more preparative Pareto optimization runs as illustrated in the next section. Thus, neither the original weighted sum nor the CWS are a priori methods. We will come back to this later.
+
+# 3.3. Example of the CWS
+
+Table 1 gives an example of the usage of weights and thresholds for a problem of scheduling jobs organized in workflows of elementary operations to heterogeneous equipment comparable to the one described in [6]. All operations can be assigned to alternatively usable equipment at different costs and processing times. The task is to produce schedules, where the job processing is as cheap and as fast as possible and each job observes a given budget and a given due date. The rate of utilization of the equipment should be as high and the total makespan of all jobs as low as possible. Additionally, the schedules must be updated frequently, because e.g., new jobs arrive or waiting jobs are cancelled. As described in Section 2.2, all objectives are normalized according to Equation (3). The required limits are obtained as follows: The bounds of job time and costs are calculated by determination of the critical path of the workflow of that job and by the assignment of the fastest/slowest or costliest/cheapest equipment suited for the operations of a job. The user-given due dates and cost limits are checked against these bounds so that the subsequent scheduling is based on goals which are achievable in principle. The lower bound of the makespan is the duration of the longest lasting job using the fastest equipment and the upper bound is the sum of the duration of all jobs using the slowest equipment divided by the smallest number of alternatively usable equipment. As the rate of utilization already yields a value to be maximized between zero and one, there is no need for bounds.
+
+Table 1. Example of the use of the cascaded weighted sum (CWS) and the effect of objective group weights. The objectives with the highest priority are always active and contribute to the weighted sum. They are marked here by a light green background.  
+
+<table><tr><td>Priority</td><td>Objective</td><td>Weight [%]</td><td>Threshold εi</td></tr><tr><td>1</td><td>job time</td><td>30</td><td>0.4</td></tr><tr><td>1</td><td>job costs</td><td>40</td><td>0.25</td></tr><tr><td>2</td><td>makespan</td><td>20</td><td>-</td></tr><tr><td>2</td><td>utilization rate</td><td>10</td><td>-</td></tr></table>
+
+Job time and costs are most conflicting, while short processing times support a short makespan and tend to increase the utilization rate. Faster equipment typically is more expensive than slower, and the ratio between costs and duration of the use of equipment will play an important role. Thus, lower costs require the usage of equipment with a lower ratio of costs and duration. This tends to increase the duration and to decrease the workload of less cost-effective equipment. Additionally, shorter job times are also rewarded to some extent by the makespan and possibly by the utilization rate, but costs are not. These considerations are supported by the observation that the processing times are easier to reduce than costs. Thus, job time and costs should compete from the beginning and both should receive a larger portion of the weights. Therefore, they are grouped together at the highest priority so that they always contribute to the weighted sum, as shown in Table 1. As a rule of thumb, further objectives,
+
+which are less conflicting with each other and those of higher priorities, can go into the same group. After having determined the priority and grouping structure based on experience and considerations about the relationships between the objectives, appropriate weights and thresholds must be chosen.
+
+Based on these considerations and a representative scheduling task, a schedule can be produced based on Pareto optimality for the identification of the region of interest, from which thresholds and weights can be derived. In the given example, this can be done in a first step for a reduced set of objectives by omitting a less conflicting one, e.g., the utilization rate. The Pareto fronts for good makespans of the two remaining objectives can be plotted. From it, the thresholds and the ratio of the weights between them can be derived, see Figure 2 for the relationship between Pareto front and the weights and Figure 5 for the usage of thresholds. This results in a ratio of 3:4 between the averaged job times and costs in the given example. The threshold values  $\varepsilon_{i}$  are used as percentage values related to the available scale between  $\min(f_i)$  and  $\max(f_i)$ , as shown in Equation (8):
+
+$$
+f _ {i, \varepsilon} = \min  \left(f _ {i}\right) + \varepsilon_ {i} \left(\max  \left(f _ {i}\right) - \min  \left(f _ {i}\right)\right) \tag {8}
+$$
+
+In this case, the objectives of the next group are activated for schedules where the costs are below  $75\%$  of their available scales on the average and the finishing times are below  $60\%$  of their spendable time frames on the average. This approach can be repeated for the rest of the objectives or the remaining weights are assigned according to experience. For the given example, it was decided based on previous observations that about  $70\%$  of the weight should go to the first two objectives and the rest should go mainly to the makespan, as its reduction tends to increase the utilization rate. Table 1 shows the resulting weights. The suitability of the settings can be verified by the generation of a Pareto optimal schedule using all objectives and the comparison with the results obtained when using the CWS instead. Depending on the task at hand and the first setting of weights and thresholds, this may result in an iterative refinement.
+
+To sum up, weights and thresholds are derived from experience and/or from previous estimations of the Pareto front of a representative task. In Section 4 we will discuss the range of meaningful applications of the CWS.
+
+# 3.4. The Effect of the CWS on the Search
+
+The effect of the cascaded assessment on population-based search procedures like EAs, PSO or ACO is illustrated in Figure 6 for two objectives and the example of the feasible objective region used in Figure 2. Based on previous knowledge, the sources of which are discussed in Section 4.3, a region of interest is defined for every objective group and the weights are set accordingly. Additionally, threshold values  $\varepsilon_{i}$  are defined for all objectives but those of the group with the lowest priority. Care must be taken for the accessibility of the region of interest being not affected by these thresholds. In the example of Figure 6, objective two has a higher priority than objective one and a threshold value  $\varepsilon_{2}$ . In the beginning of the search, a quality gain can be achieved for upward moves only. For those solutions that have surpassed  $\varepsilon_{2}$ , the result of the first objective is added according to the weights changing the average movement direction towards the tangent and the region of interest. If the search runs long enough to come more or less close to convergence, most solutions will be found in the region of interest. The best of them will be at the intersection of the tangent and the Pareto front or at least
+
+close to it. Especially for EAs, which preserve genotypic diversity to some extent, good but suboptimal solutions close to the best one covering at least parts of the area of interest are very likely to be found. This means that a run is stopped when stagnation occurs over a longer period of time and not when the entire population has (nearly) converged.
+
+![](images/bc4466dbc4d4b1cde5c14e6ac3a6ad1de60037ecbe7155acc7a896c415e14c49.jpg)  
+Figure 6. Cascaded weighted sum for  $k = 2$  and objective two having a higher priority than objective one. Thus, solutions in the hatched area are bettered according to  $f_{2}$  only and will find the largest quality gain in upward moves (red arrow). This changes, if  $\varepsilon_{2}$  is exceeded and  $f_{1}$  starts to contribute to the resulting sum, as shown by the black arrows.
+
+An example of a Pareto front with a non-convex section is shown in Figure 7 using the objective region and the threshold value of Figure 5. As the part between F2 and the rightmost end of the Pareto front is quasi excluded, it is possible now to obtain solutions in the marked area of interest. This would not be the case for the original weighted sum. On the other hand, if the region of interest was located between the magenta dot and F2, most of the Pareto front would still be missed.
+
+![](images/1dbfe304cae12f98c4baf10cd2f1ca0452a93817e33d3f6c72e1477bc15bd78b.jpg)  
+Figure 7. Cascaded weighted sum and region of interest for the example with a non-convex Pareto front given in Figure 5.
+
+Normalization according to Equations (3) or (4) is done linearly with the same ratio for the entire interval  $[\min(f_i), \max(f_i)]$ . If previous knowledge is available for defining an area of interest for the Pareto front, corresponding subintervals are also known for the single objectives. This information can be used to tune the normalization function, as is shown exemplarily in Figure 8. More normalization functions can be found in [15].
+
+![](images/89768f1ec4562c6ae09740de3232f4a36b9f8c4dc34b67b5c287ee832d694a25.jpg)  
+Figure 8. Tuning the normalization of Equation (3) (blue straight line) to the interval of interest of one objective  $f_{i}$ . The decline outside of this interval is reduced drastically to allow for a strong increase inside, as shown by the green graph.
+
+# 3.5. Summary
+
+The grouping of the CWS reduces the amount of objectives considered at once and makes weighting easier. The CWS integrates objective thresholds comparable to those of the  $\varepsilon$ -constrained method, which are easier to handle for experts in the application field than weights, which now play a relatively minor role. The CWS allows for obtaining parts of a non-convex Pareto front, which were unreachable for the original weighted sum. However, it is still possible that some of these parts remain unattainable. These arguments underline the superiority of the CWS over the pure weighted sum. All aggregation methods alone are not suited as a priori approaches, as they require some previous knowledge to be parameterized.
+
+# 4. Cascaded Weighted Sum and Its Field of Application
+
+Optimization problems can be classified according to different criteria, such as the number of decision variables or of objectives, or the nature of the search space, where the number of (expected) suboptima or continuity plays an important role, or the type of project to which the optimization project belongs. The latter is often ignored in scientific literature, although it plays a significant role in real-world applications. Thus, we will take a closer look at that issue in the next sections. We will also consider the amount of objectives, as both properties are well suited to compare both assessment methods.
+
+# 4.1. Number of Objectives
+
+As already discussed in Section 3.3 objectives can conflict more or less. We consider here only objectives, the decision maker regards as conflicting in the sense that they shall be part of Pareto optimality. The amount of these objectives plays an important role for the practical applicability of the Pareto method. The Pareto front of up to three objectives can be visualized easily. For up to four or five objectives, decision maps, polyhedral approximation, or other visualization techniques can be used, see [20]. Interactive visualization techniques may support perception for more than three objectives, "but this requires more cognitive effort if the number of objectives increases", as Lotov and Miettinen summarize their chapter on visualization of the Pareto frontier in [20]. Thus, we can conclude that from five and in particular from more criteria, the perception and the comprehension of the Pareto front become increasingly difficult and turn into a business for experienced experts.
+
+![](images/0450b4aba2b2c319bfbc17b937ade1132c3fcb8c2077e942162cf78b7f215051.jpg)  
+Figure 9. The number of required data points (Pareto-optimal solutions) of an approximation of a Pareto front increases exponentially with a growing number of conflicting objectives. The green line is based on a resolution of 7 data points per additional objective (axis), while the blue one uses 5 only.
+
+Another question is the effort to determine the Pareto front. For an acceptable visualization of the Pareto front, approximations like the one described in [21] may be used. Depending on the desired quality of approximation, a number of 5 to 7, in general  $s$ , Pareto-optimal solutions may be sufficient for two objectives. Assuming that the same quality of interpolation and granularity of support points shall be maintained when further objectives are added,  $s^{(k - 1)}$  support points are required for the interpolation of the hyperplane of the Pareto front, provided that all areas shall be examined. With interactive approaches, this can be reduced to some extent, but at the risk of missing promising regions. Figure 9 illustrates this growth of required Pareto optimal solutions. For 5 objectives, for example, 625 solutions are required to interpolate the entire hyperplane with 5 data points per axis. For a better interpolation quality obtained from 7 data points per axis 2401 solutions are needed. It should be noted that every data point requires several evaluations of solutions according to the optimization
+
+or approximation procedure used. Depending on the application, evaluations may be based on time-consuming simulations and last several seconds or minutes each. This clearly limits the practical applicability of the Pareto method for growing numbers of conflicting objectives. One solution is to reduce the number of objectives by an aggregation of less conflicting objectives to one.
+
+# 4.2. Classification of Application Scenarios and Examples
+
+Optimization projects can be classified into three different types:
+
+I. The nonrecurring type, which is performed once with little or no prior knowledge of e.g., the impact and relevance of decision variables or the behavior of objectives. This type requires many decisions regarding e.g., the number and ranges of decision variables, the number and kind of objectives, of restrictions, and more.  
+II. The extended nonrecurring project, where some variants of the first optimization task are handled as well. Frequently, the modifications of the original project are motivated by the experience gained in the first optimization runs. As in the first type, decisions are usually made by humans.  
+III. The recurring type, usually based on experience gained from a predecessor project and frequently part of an automated process without or with minor human interaction only.
+
+Examples of Types I and II are design optimization tasks like the design of micro-optical devices as described in [22] or problems from such a challenging field like aerodynamic design optimization, see e.g., [23]. A typical example of type III is the task of scheduling jobs to be processed on a computational grid as introduced in the last section and described in detail in [6]. Normally, nobody is interested in the details of the actual schedule, which usually will be replaced soon by a new one due to a replanning event like a new job to be planned or the introduction of new resources. Another example is the planning of collision-free paths for movements of industrial robots, as described in detail and for different industrial robot types in [14,15,24,25]. This example also shows that in some cases human judgment is possible in addition to a pure consideration of the achieved objective figures of a generated robot move path. The decision maker can take a look at the resulting movement using a robot simulator or the real device. Assessing this movement is much more impressive and illustrative than reading objective figures. On the other hand, such a well-fitting visualization is not always available.
+
+# 4.3. Comparison of Pareto Optimization and CWS in Different Application Scenarios
+
+# 4.3.1. Individual Optimization Project
+
+For the first project type, the ranges of possibly achievable objective values usually are not known in advance. In this case, an estimation of them can be obtained from a Pareto optimization. From these data and the resulting Pareto front, a human decision maker can opt for additional and modified optimization or select the final solution. This type of optimization project clearly belongs to the domain of Pareto-based optimization.
+
+# 4.3.2. Optimization Project with Some Task Variants
+
+In many cases, the above statement also applies to the second project type, as experience is still limited and there must be good reasons to change the assessment method. Such a reason may be more than five objectives and if one or few areas of interest can be identified. In such cases, the computational effort can be reduced significantly. As mentioned before, an assessment of one solution in real world applications is frequently done by a simulation run, the duration of which strongly depends on the application at hand. One simulation may require seconds or even minutes and more. In such cases, the reduction of the number of evaluations is critical and an early concentration on the area of interest by using the CWS can be essential for the success of the project. On the other hand, the impact of the optimization is another important and application-dependent issue: If the savings expected from optimization justify the computational effort, Pareto optimization should be used until the areas of interest are reliably identified. Based on that, these areas can be explored in greater detail by optimization runs using the CWS, as illustrated in Figure 10. These considerations show that according to the project conditions, both methods may complement each other.
+
+![](images/3f12a0652514fdf41070930abd560c4cb3e319f17d304332fb21977608bbf040.jpg)  
+Figure 10. Both diagrams show a sample population of an advanced search more or less shortly before convergence. The CWS concentrates the best individuals (black dots) more or less on the region of interest, as shown in the left diagram. In contrast to that, Pareto-based optimization procedures attempt to distribute their solutions along the Pareto front as best as they can, see the right diagram. Thus, fewer solutions will be found in the area of interest.
+
+# 4.3.3. Repeated Optimization, also as Part of an Automated Process
+
+Another domain of CWS-based optimization or planning is project type III, where the same task is executed repeatedly with minor modifications and, thus, known areas of interest. If a major change occurs, the area of interest can be adapted by using Pareto optimization. A typical example is the scheduling of jobs to the heterogeneous resources of a computational grid, as was introduced before and described in detail in [6]. It is a permanent replanning process, because events demanding a change of the schedule may occur long before a plan is completed. Examples are the introduction of new jobs or new resources, unexpected deactivations of resources, changes of the cost profiles of
+
+resources, early completion of jobs, or the like. As described in [6], five objectives are optimized and four penalty functions are used to handle the restrictions. Because planning time is limited and thousands of jobs and hundreds of resources must be handled, the planning must be stopped (long) before the used Evolutionary Algorithm converges. Thus, it is important to explore the region of interest as well as possible, see Figure 10. Additionally, there is no human expert to check the results several times per hour. For this automated scheduling process, the determination of the Pareto front makes no sense and the CWS is a meaningful alternative. These considerations also apply to many other scheduling tasks like the one described in [15,19].
+
+Another example already mentioned is the planning of collision-free movement paths for an industrial robot [14,15,24,25]. Depending on the task at hand, we have four or five objectives and at the minimum one penalty function to handle collisions. As robot movements can be simulated and visualized, the results are checked by a human expert mostly on the level of robot movements rather than of objective figures. As areas of interest usually are also known in advance and new solutions should be generated fast, the CWS is suited here as well and for the same reasons as with the task before.
+
+# 5. Conclusions
+
+In Section 4.1 it was shown that the amount of solutions required to approximate a Pareto front increases exponentially with a growing number of conflicting objectives. As illustrated in Figure 9, the amount of evaluations increases considerably for more than five objectives. This limits the applicability of the Pareto approach for real-world applications, which frequently require time-consuming evaluations especially when based on simulation.
+
+We have introduced the cascaded weighted sum (CWS), which can be described roughly as a combination of the weighted sum and the  $\varepsilon$ -constrained method. The major drawback of the pure weighted sum, the inaccessibility of parts of the Pareto front in non-convex cases, can be reduced to some extent by the CWS, see Section 3 and Figure 7. As the pure weighted sum, the CWS is not an a priori method. The major advantage of the CWS is its ability to concentrate solutions on the region of interest with less computational effort than Pareto optimization. In addition, this effort difference increases immensely with an increasing number of objectives, in particular for more than five. The region of interest can be a result of previous experience or knowledge, of a first Pareto-based optimization, or a combination thereof.
+
+In Section 4.2, optimization projects were divided into three types, the individual project type, projects treating some variants of the task, and the type of repeated optimization of the same task with more or less small variations. The unquestioned domain of Pareto optimization is the first type of optimization projects. For the second type and five or more objectives, a combination of both methods can be advantageous as was described in Section 4.3.2. For the third project type of repeated optimization of task variants and with no or only minor human interaction, the Pareto front is not required, as the regions of interest are already known from previous solutions or initial Pareto optimization. The concentration of the CWS on that region is beneficial, as the computational effort can be reduced significantly. This is of importance especially in those cases, where a fast solution is required or the amount of evaluations is limited due to long run times.
+
+Thus, we can conclude that both methods have their place and their field of application. Additionally, they can complement each other.
+
+# Acknowledgments
+
+We acknowledge support by the Deutsche Forschungsgemeinschaft and Open Access Publishing Fund of Karlsruhe Institute of Technology.
+
+# Conflicts of Interest
+
+The authors declare no conflict of interest.
+
+# References
+
+1. Pareto, V. Cours d'Économie Politique, (in French); F. Rouge: Lausanne, Switzerland, 1896.  
+2. Hoffmeister, F.; Bäck, T. Genetic Algorithms and Evolution Strategies: Similarities and Differences; Technical Report SYS-1/92; FB Informatik, University of Dortmund: Dortmund, Germany, 1992.  
+3. Multiobjective Optimization: Interactive and Evolutionary Approaches; Lecture notes in computer science 5252; Branke, J., Deb, K., Miettinen, K., Sławinski, R., Eds.; Springer: Berlin, Germany, 2008.  
+4. Deb, K. Introduction to evolutionary multiobjective optimization. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Slosinski, R., Eds.; Lecture notes in computer science 5252; Springer: Berlin, Germany, 2008; pp. 58-96.  
+5. Miettinen, K. Nonlinear Multiobjective Optimization; International series in operations research & management science 12; Kluwer Academic Publishers: Boston, MA, USA, 1999.  
+6. Jakob, W.; Strack, S.; Quinte, A.; Bengel, G.; Stucky, K.-U.; Süß, W. Fast rescheduling of multiple workflows to constrained heterogeneous resources using multi-criteria memetic computing. Algorithms 2013, 2, 245-277.  
+7. Haimes, Y.Y.; Lasdon, L.S.; Wismer, D.A. On a bicriterion formulation of the problems of integrated system identification and system optimization. IEEE Trans. Syst. Man Cybern. 1971, 3, 296-297.  
+8. Osyczka, A. Multicriterion Optimization in Engineering with FORTRAN Programs; Ellis Horwood series in mechanical engineering; E. Horwood: London, UK, 1984.  
+9. Miettinen, K. Introduction to multiobjective optimization: Noninteractive approaches. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Słowyński, R., Eds.; Lecture notes in computer science 5252; Springer: Berlin, Germany, 2008; pp. 1-26.  
+10. Deb, K.; Pratap, A.; Agarwal, S.; Meyarivan, T. A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE Trans. Evol. Comput. 2002, 2, 182-197.  
+11. Zitzler, E.; Laumanns, M.; Thiele, L. SPEA2: Improving the strength pareto evolutionary algorithm for multiobjective optimization. In Evolutionary Methods for Design Optimization and Control with Applications to Industrial Problems, Proceedings of the EUROGEN'2001 Conference, Athens, Greece, 19-21 September 2001; Giannakoglou, K.C., Tsahalis, D.T., Périaux,
+
+J., Papailiou, K.D., Fogarty, T., Eds.; International Center for Numerical Methods in Engineering: Athens, Greece: 2001; pp. 95-100.  
+12. Beume, N.; Naujoks, B.; Emmerich, M. SMS-EMOA: Multiobjective selection based on dominated hypervolume. Eur. J. Oper. Res. 2007, 3, 1653–1669.  
+13. Blume, C. GLEAM—A system for simulated "intuitive learning". In Parallel Problem Solving from Nature: Proceedings of the 1st Workshop, Dortmund, Germany, 1-3 October 1990; Schwefel, H.-P., Manner, R., Eds.; Lecture notes in computer science 496; Springer: Berlin, Germany, 1991; pp. 48-54.  
+14. Blume, C.; Jakob, W.; Krisch, S. Robot trajectory planning with collision avoidance using genetic algorithms and simulation. In Proceedings of the 25th International Symposium on Industrial Robots (ISIR), Hanover, Germany, 25-27 April, 1994; pp. 169-175.  
+15. Blume, C.; Jakob, W. GLEAM—General Learning Evolutionary Algorithm and Method. Ein evolutionärer Algorithmus und seine Anwendungen, (in German); Schriftenreihe des Instituts für Angewandte Informatik, Automatisierungstechnik am Karlsruhe Institut für Technologie 32; KIT Scientific Publishing: Karlsruhe, Germany, 2009.  
+16. Gorges-Schleuter, M. Explicit parallelism of genetic algorithms through population structures. In Proceedings of the 1st Workshop on Parallel Problem Solving from Nature (PPSN I), Dortmund, Germany, 1-3 October 1990; Schwefel, H.-P., Manner, R., Eds.; LNCS 496, Springer: Berlin, Germany, 1991; pp. 150-159.  
+17. Sarma, K.; de Jong, K. An analysis of the effects of neighborhood size and shape on local selection algorithms. In Proceedings of the 4th International Conference on Parallel Problem Solving from Nature (PPSN IV), LNCS 1141, Berlin, Germany, 22-26 September 1996; Voigt, H.-M., Ebeling, W., Rechenberg, I., Schwefel, H.-P., Eds.; Springer: Berlin, Germany, 1996; pp. 236-244.  
+18. Nguyen, Q.H.; Ong, Y.-S.; Lim, M.H.; Krasnogor, N. Adaptive cellular memetic algorithms. Evol. Comput. 2009, 17, 231-256.  
+19. Jakob, W. A general cost-benefit-based adaptation framework for multimeme algorithms. Memet. Comput. 2010, 3, 201-218.  
+20. Lotov, A.V.; Miettinen, K. Visualizing the Pareto Frontier. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Słowyński, R., Eds.; Lecture notes in computer science 5252; Springer: Berlin, Germany, 2008; pp. 213-243.  
+21. Klamroth, K.; Tind, J.; Wiecek, M.M. Unbiased approximation in multicriteria optimization. Math. Method Oper. Res. 2003, 3, 413-437.  
+22. Jakob, W.; Gorges-Schleuter, M.; Sieber, I.; Suß, W.; Eggert, H. Solving a highly multi-modal design optimization problem using the extended genetic algorithm GLEAM. In Computer Aided Optimum Design of Structures VI: Conf. Proc. OPTI 99; Hernandez, S., Kassab, A.J., Brebbia, C.A., Eds.; WIT Press: Southampton, UK, 1999; pp. 205-214.
+
+23. Stewart, T.; Bandte, O.; Braun, H.; Chakraborti, N.; Ehrgott, M.; Göbelt, M.; Jin, Y.; Nakayama, H.; Poles, S.; di Stefano, D. Real-world applications of multiobjective optimization. In Multiobjective Optimization: Interactive and Evolutionary Approaches; Branke, J., Deb, K., Miettinen, K., Słowyński, R., Eds.; Lecture notes in computer science 5252; Springer-Verlag: Berlin, Germany, 2008; pp. 285-327.  
+24. Blume, C. Automatic Generation of Collision Free Moves for the ABB Industrial Robot Control. In Proceedings of the 1997 First International Conference on Knowledge-Based Intelligent Electronic Systems (KES '97), Adelaide, SA, Australia, 21-23 May 1997; Volume 2, pp. 672-683.  
+25. Blume, C. Optimized Collision Free Robot Move Statement Generation by the Evolutionary Software GLEAM. In Real World Applications of Evolutionary Computing: Proceedings; Cagnoni, S., Ed.; Lecture notes in computer science 1803; Springer: Berlin, Germany, 2000; pp. 327-338.  
+© 2014 by the authors; licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution license (http://creativecommons.org/licenses/by/3.0/).

2203.02xxx/2203.02697/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09d5347591ab0fd367ff009141c216b662bfe4c08fcd3753afb991d9d44bb7b7
+size 321706

2203.02xxx/2203.02700/3d69ca7f-39a5-4c99-b9df-bcb921fe9d04_content_list.json

@@ -0,0 +1,1543 @@
+[
+    {
+        "type": "text",
+        "text": "RACE: Retrieval-Augmented Commit Message Generation",
+        "text_level": 1,
+        "bbox": [
+            193,
+            79,
+            803,
+            99
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ensheng Shi $^{a}$  Yanlin Wang $^{b,\\S,\\dagger}$  Wei Tao $^{c}$  Lun Du $^{d}$",
+        "bbox": [
+            292,
+            105,
+            712,
+            123
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hongyu Zhang<sup>e</sup> Shi Hand Dongmei Zhang<sup>d</sup> Hongbin Sun<sup>a,§</sup>",
+        "bbox": [
+            247,
+            123,
+            754,
+            140
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$^{a}$ Xi'an Jiaotong University  $^{b}$ School of Software Engineering, Sun Yat-sen University",
+        "bbox": [
+            149,
+            140,
+            852,
+            156
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$^{c}$ Fudan University  $^{d}$ Microsoft Research  $^{e}$ The University of Newcastle",
+        "bbox": [
+            200,
+            156,
+            801,
+            173
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "s1530129650@stu.xjtu.edu.cn, hsun@mail.xjtu.edu.cn",
+        "bbox": [
+            250,
+            175,
+            752,
+            189
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "wangylin36@mail.sysu.edu.cn，wtao18@fudan.edu.cn",
+        "bbox": [
+            257,
+            191,
+            742,
+            206
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{lun.du, shihan, dongmeiz}@microsoft.com",
+        "bbox": [
+            300,
+            208,
+            704,
+            222
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "hongyu.zhang@newcastle.edu.au",
+        "bbox": [
+            354,
+            224,
+            648,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            260,
+            252,
+            339,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Commit messages are important for software development and maintenance. Many neural network-based approaches have been proposed and shown promising results on automatic commit message generation. However, the generated commit messages could be repetitive or redundant. In this paper, we propose RACE, a new retrieval-augmented neural commit message generation method, which treats the retrieved similar commit as an exemplar and leverages it to generate an accurate commit message. As the retrieved commit message may not always accurately describe the content/intent of the current code diff, we also propose an exemplar guider, which learns the semantic similarity between the retrieved and current code diff and then guides the generation of commit message based on the similarity. We conduct extensive experiments on a large public dataset with five programming languages. Experimental results show that RACE can outperform all baselines. Furthermore, RACE can boost the performance of existing Seq2Seq models in commit message generation. Our data and source code are available at https://github.com/DeepSoftwareAnalytics/RACE.",
+        "bbox": [
+            144,
+            279,
+            460,
+            661
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction",
+        "text_level": 1,
+        "bbox": [
+            114,
+            674,
+            258,
+            688
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In software development and maintenance, source code is frequently changed. In practice, code changes are often documented as natural language commit messages, which summarize what (content) the code changes are or why (intent) the code is changed (Buse and Weimer, 2010; Cortes-Coy et al., 2014). High-quality commit messages are essential to help developers understand the evolution of software without diving into implementation details, which can save a large amount of",
+        "bbox": [
+            112,
+            699,
+            489,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "time and effort in software development and maintenance (Dias et al., 2015; Barnett et al., 2015). However, it is difficult to write high-quality commit messages due to lack of time, clear motivation, or experienced skills. Even for seasoned developers, it still poses a considerable amount of extra workload to write a concise and informative commit message for massive code changes (Nie et al., 2021). It is also reported that around  $14\\%$  of commit messages over 23,000 projects in SourceForge are left empty (Dyer et al., 2013). Thus, automatically generating commit messages becomes an important task.",
+        "bbox": [
+            507,
+            253,
+            884,
+            462
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Over the years, many approaches have been proposed to automatically generate commit messages. Early studies (Shen et al., 2016; Cortes-Coy et al., 2014) are mainly based on predefined rules or templates, which may not cover all situations or comprehensively infer the intentions behind code changes. Later, some studies (Liu et al., 2018; Huang et al., 2017, 2020) adopt information retrieval (IR) techniques to reuse commit messages of similar code changes. They can take advantage of similar examples, but the reused commit messages might not correctly describe the content/intent of the current code change. Recently, some Seq2Seq-based neural network models (Loyola et al., 2017; Jiang et al., 2017; Xu et al., 2019; Liu et al., 2019; Jung, 2021) have been proposed to understand code diffs and generate the high-quality commit messages. These approaches show promising performance, but they tend to generate high-frequency and repetitive tokens and the generated commit messages have the problem of insufficient information and poor readability (Wang et al., 2021a; Liu et al., 2018). Some studies (Liu et al., 2020; Wang et al., 2021a) also explore the combination of neural-based and IR-based techniques. Liu et al. (2020) propose an approach to rank the retrieved commit message (obtained by a simple IR-based model) and the generated commit message (ob-",
+        "bbox": [
+            507,
+            468,
+            884,
+            919
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "aside_text",
+        "text": "arXiv:2203.02700v3 [cs.SE] 22 Oct 2022",
+        "bbox": [
+            21,
+            312,
+            60,
+            725
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "$^{\\S}$  Yanlin Wang and Hongbin Sun are the corresponding authors.",
+        "bbox": [
+            112,
+            866,
+            487,
+            891
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_footnote",
+        "text": "$^{\\dagger}$ Work done during the author's employment at Microsoft Research Asia",
+        "bbox": [
+            112,
+            892,
+            485,
+            917
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "tained by a neural network model). Wang et al. (2021a) propose to use the similar code diff as auxiliary information in the inference stage, while the model is not trained to learn how to effectively utilize the information of retrieval results. Therefore, both of them fail to take advantage of the information of retrieved similar results well.",
+        "bbox": [
+            112,
+            84,
+            489,
+            197
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a novel model RACE (Retrieval-Augmented Commit mEssay generation), which retrieves a similar commit message as an exemplar, guides the neural model to learn the content of the code diff and the intent behind the code diff, and generates the readable and informative commit message. The key idea of our approach is retrieval and augmentation. Specifically, we first train a code diff encoder to learn the semantics of code diffs and encode the code diff into high-dimensional semantic space. Then, we retrieve the semantically similar code diff paired with the commit message on a large parallel corpus based on the similarity measured by vectors' distance. Next, we treat the similar commit message as an exemplar and leverage it to guide the neural-based models to generate an accurate commit message. However, the retrieved commit messages may not accurately describe the content/intent of current code diffs and may even contain wrong or irrelevant information. To avoid the retrieved samples dominating the processing of commit message generation, we propose an exemplar guider, which first learns the semantic similarity between the retrieved and current code diff and then leverages the information of the exemplar based on the learned similarity to guide the commit message generation.",
+        "bbox": [
+            115,
+            204,
+            490,
+            639
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effectiveness of RACE, we conduct experiments on a large-scale dataset MCMD (Tao et al., 2021) with five programming language (Java, C#, C++, Python and JavaScript) and compare RACE with 11 state-of-the-art approaches. Experimental results show that: (1) RACE significantly outperforms existing state-of-the-art approaches in terms of four metrics (BLUE, Meteor, Rouge-L and Cider) on the commit message generation. (2) RACE can boost the performance of existing Seq2Seq models in commit message generation. For example, it can improve the performance of NMTGen (Loyola et al., 2017), CommitBERT (Jung, 2021), CodeT5-small (Wang et al., 2021b) and CodeT5-base (Wang et al., 2021b) by  $43\\%$ ,  $11\\%$ ,  $15\\%$ , and  $16\\%$  on average in terms of BLEU, respectively. In addition,",
+        "bbox": [
+            112,
+            645,
+            490,
+            920
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "we also conduct human evaluation to confirm the effectiveness of RACE.",
+        "bbox": [
+            507,
+            84,
+            880,
+            115
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We summarize the main contributions of this paper as follows:",
+        "bbox": [
+            507,
+            116,
+            880,
+            148
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "list",
+        "sub_type": "text",
+        "list_items": [
+            "- We propose a retrieval-augmented neural commit message generation model, which treats the retrieved similar commit as an exemplar and leverages it to guide neural network model to generate informative and readable commit messages.",
+            "- We apply our retrieval-augmented framework to four existing neural network-based approaches (NMTGen, CommitBERT, CodeT5-small, and CodeT5-base) and greatly boost their performance.",
+            "- We perform extensive experiments including human evaluation on a large multi-programming-language dataset and the results confirm the effectiveness of our approach over state-of-the-art approaches."
+        ],
+        "bbox": [
+            531,
+            158,
+            884,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work",
+        "text_level": 1,
+        "bbox": [
+            509,
+            443,
+            665,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Code intelligence, which leverages machine learning especially deep learning-based method to understand source code, is an emerging topic and has obtained the promising results in many software engineering tasks, such as code summarization (Zhang et al., 2020; Shi et al., 2021a, 2022b; Wang et al., 2020) and code search (Gu et al., 2018; Du et al., 2021; Shi et al., 2022a). Among them, commit message generation plays an important role in the software evolution.",
+        "bbox": [
+            507,
+            468,
+            884,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In early work, information retrieval techniques are introduced to commit message generation (Liu et al., 2018; Huang et al., 2017, 2020). For instance, ChangeDoc (Huang et al., 2020) retrieves the most similar commits according to the syntax or semantics in the code diff and reuses commit messages of similar code diffs. NNGen (Liu et al., 2018) is a simple yet effective retrieval-based method using the nearest neighbor algorithm. It firstly recalls the top-k similar code diffs in the parallel corpus based on cosine similarity between bag-of-words vectors of code diffs. Then select the most similar result based on BLEU scores between each of them (topk results) and the input code diff. These approaches can reuse similar examples and the reused commit messages are usually readable and understandable.",
+        "bbox": [
+            507,
+            629,
+            882,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, many neural-based approaches (Loyola et al., 2017; Jiang et al., 2017; Xu et al., 2019;",
+        "bbox": [
+            507,
+            887,
+            882,
+            917
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Liu et al., 2019, 2020; Jung, 2021; Dong et al., 2022; Nie et al., 2021; Wang et al., 2021a) have been used to learn the semantic of code diffs and translate them into commit messages. For example, NMTGen (Loyola et al., 2017) and CommitGen (Jiang et al., 2017) treat the code diffs as plain texts and adopt the Seq2Seq neural network with different attention mechanisms to translate them into commit messages. CoDiSum (Xu et al., 2019) extracts both code structure and code semantics from code diffs and jointly models them with a multi-layer bidirectional GRU to better learn the representations of code diffs. PtrGNCMsg (Liu et al., 2019) incorporates the pointer-generator network into the Seq2Seq model to handle out-of-vocabulary (OOV) words. CommitBERT leverage CodeBERT (Feng et al., 2020), a pre-trained language model for source code, to learn the semantic representations of code diffs and adopt a Transformer-based (Vaswani et al., 2017) decoder to generate the commit message. These approaches show promising results on the generation of commit messages.",
+        "bbox": [
+            115,
+            84,
+            489,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, introducing retrieved relevant results into the training process has been found useful in most generation tasks (Lewis et al., 2020; Yu et al., 2021; Wei et al., 2020). Some studies (Liu et al., 2020; Wang et al., 2021a) also explore the combination of neural-based models and IR-based techniques to generate commit messages. ATOM (Liu et al., 2020) ensembles the neural-based model and the IR-based technique through the hybrid ranking. Specifically, it uses BiLSTM to encode ASTs paths extracted from ASTs of code diffs and adopt a decoder to generate commit messages. It also uses TF-IDF technique to represent code diffs as vectors and retrieves the most similar commit message based on cosine similarity. The generated and retrieved commit messages are finally prioritized by a hybrid ranking module. CoRec (Wang et al., 2021a) is also a hybrid model and only considers the retrieved result during the inference. Specifically, at the training stage, they use an encoder-decoder neural model to encode the input code diffs by an encoder and generate commit messages by a decoder. At the inference stage, they first use the trained encoder to retrieve the most similar code diff from the training set. Then they reuse a trained encoder-decoder to encode the input and retrieved code diff, combine the probability distributions (obtained by two decoders) of each word, and generate",
+        "bbox": [
+            115,
+            468,
+            487,
+            917
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "the final commit message step by step. In summary, ATOM does not learn to refine the retrieved results or the generated results, and CoRec is not trained to utilize the information of retrieval results. Therefore, both of them fail to take full advantage of the retrieved similar results. In this paper, we treat the retrieved similar commit as an exemplar and train the model to leverage the exemplar to enhance commit message generation.",
+        "bbox": [
+            510,
+            84,
+            884,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Proposed Approach",
+        "text_level": 1,
+        "bbox": [
+            510,
+            243,
+            714,
+            260
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The overview of RACE is shown in Figure 1. It includes two modules: retrieval module and generation module. Specifically, RACE firstly retrieves the most semantically similar code diff paired with the commit message from the large parallel training corpus. The semantic similarity between two code diffs is measured by the cosine similarity of vectors obtained by a code diff encoder. Next, RACE treats the retrieved commit message as an example and uses it to guide the neural network to generate an understandable and concise commit message.",
+        "bbox": [
+            510,
+            269,
+            884,
+            447
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Retrieval module",
+        "text_level": 1,
+        "bbox": [
+            510,
+            460,
+            690,
+            475
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this module, we aim to retrieve the most semantically similar result. Specifically, we first train an encoder-decoder neural network on the large commit message generation dataset. The encoder is used to learn the semantics of code diffs and encode code diffs into a high-dimension semantic space. Then we retrieve the most semantically similar code diff paired with the commit message from the large parallel training corpus. The semantic similarity between two code diffs is measured by the cosine similarity of vectors obtained by a well-trained code diff encoder.",
+        "bbox": [
+            510,
+            483,
+            884,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, encoder-decoder neural network models (Loyola et al., 2017; Jiang et al., 2017; Jung, 2021), which leverage an encoder to learn the semantic of code diff and employ a decoder to generate the commit message, have shown their superiority in the understanding of code offs and commit messages generation. To enable the code diff encoder to understand the semantics of code offs, we train it with a commit message generator on a large commit message generation dataset, which consists of about 0.9 million <code diff, commit message> pairs.",
+        "bbox": [
+            510,
+            677,
+            884,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To capture long-range dependencies (e.g. a variable is initialized before the changed line) and more contextual information of code diffs, we em",
+        "bbox": [
+            510,
+            871,
+            882,
+            917
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd4aef83d51ff54aa0f9e77f50d30f3d1820f9418368e54b218e777453a75071.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            84,
+            803,
+            186
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f23e86417c1a02989374e6f2ce6197fd5f838385a9bb232fd5ef16290277b89.jpg",
+        "image_caption": [
+            "Figure 1: The architecture of RACE. It includes two modules: retrieval module and generation module. The retrieval module is used to retrieve the most similar code diff and commit message. The generation module leverages the retrieved result to enhance the performance of neural network models."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            189,
+            803,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ploy a Transformer-based encoder to learn the semantic representations of input code diffs. As shown in Figure 1, a Transformer-based encoder is stacked with multiple encoder layers. Each layer consists of four parts, namely, a multi-head self-attention module, a relative position embedding module, a feed forward network (FFN) and an add & norm module. In  $b$ -th attention head, the input  $\\mathbf{X}^{\\mathrm{b}} = (\\mathbf{x}_1^{\\mathrm{b}},\\mathbf{x}_2^{\\mathrm{b}},\\dots,\\mathbf{x}_1^{\\mathrm{b}})$  (where  $\\mathbf{X}^{\\mathrm{b}} = \\mathbf{X}[(b - 1)*head_{dim}:b*head_{dim}]$ ,  $\\mathbf{X}$  is the sequence of code diff embedding,  $head_{dim}$  is the dimension of each head and  $l$  is the input sequence length.) is transformed to  $(\\mathbf{Head}^{b} = \\mathbf{head}_{1}^{\\mathrm{b}},\\mathbf{head}_{2}^{\\mathrm{b}},\\dots,\\mathbf{head}_{l}^{\\mathrm{b}})$  by:",
+        "bbox": [
+            112,
+            393,
+            489,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {h e a d} _ {\\mathrm {i}} ^ {\\mathrm {b}} = \\sum_ {j = 1} ^ {l} \\alpha_ {i j} \\left(\\mathbf {W} _ {\\mathbf {V}} \\mathbf {x} _ {\\mathrm {j}} ^ {\\mathrm {b}} + \\mathbf {p} _ {\\mathrm {i j}} ^ {\\mathbf {V}}\\right) \\tag {1}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            174,
+            626,
+            485,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\ne _ {i j} = \\frac {\\left(\\mathbf {W _ {Q}} \\mathbf {x _ {i} ^ {b}}\\right) ^ {T} \\left(\\mathbf {W _ {K}} \\mathbf {x _ {j} ^ {b}} + \\mathbf {p _ {i j} ^ {K}}\\right)}{\\sqrt {d _ {k}}}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            203,
+            664,
+            423,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $\\alpha_{ij} = \\frac{\\exp e_{ij}}{\\sum_{k=1}^{n}\\exp e_{ik}}$ ,  $\\mathbf{W}_{\\mathbf{Q}}$ ,  $\\mathbf{W}_{\\mathbf{K}}$  and  $\\mathbf{W}_{\\mathbf{V}}$  are learnable matrix for queries, keys and values.  $d_k$  is the dimension of queries and keys;  $\\mathbf{p}_{\\mathbf{ij}}^{\\mathbf{K}}$  and  $\\mathbf{p}_{\\mathbf{ij}}^{\\mathbf{V}}$  are relative positional representations for positions  $i$  and  $j$ .",
+        "bbox": [
+            112,
+            700,
+            487,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The outputs of all heads are concatenated and then fed to the FFN modules which is a multi-layer perception. The add & norm operation are employed after the multi-head attention and FFN modules. The calculations are as follows:",
+        "bbox": [
+            112,
+            785,
+            489,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\begin{array}{l} \\mathbf {H e a d} = C o n c a t \\left(\\mathbf {H e a d} ^ {\\mathbf {1}}, \\mathbf {H e a d} ^ {\\mathbf {d}}, \\mathbf {H e a d} ^ {\\mathbf {B}}\\right) \\\\ \\mathbf {H i d} = a d d \\& n o r m (\\mathbf {H e a d}, \\mathbf {X}) \\end{array} \\tag {2}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            149,
+            869,
+            487,
+            904
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {E n c} = a d d \\& n o r m (\\mathbf {F F N} (\\mathbf {H i d}), \\mathbf {H i d})\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            161,
+            907,
+            431,
+            921
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where  $add\\&norm(\\mathbf{A_1},\\mathbf{A_2}) = LN(\\mathbf{A_1} + \\mathbf{A_2})$ $B$  is the number of heads and  $LN$  is layer normalization. The final output of encoder is sent to Transformer-based decoder to generate the commit message step by step. We use cross-entropy as loss function and adopt AdamW (Loshchilov and Hutter, 2019) to optimize the parameters of the code diff encoder and the decoder at the top of Figure 1.",
+        "bbox": [
+            507,
+            393,
+            884,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, the retrieval module is used to retrieve the most similar result from a large parallel training corpus. We firstly use the above code diff encoder to map code diffs into a high-dimensional latent space and retrieve the most similar example based on cosine similarity.",
+        "bbox": [
+            507,
+            523,
+            882,
+            620
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Specifically, after being trained in the commit message generation dataset, the code diff encoder can capture the semantic of code diff well. We use well-trained code diff encoder following a mean-pooling operation to map the code diff into a high dimensional space. Mathematically, given the input code diff embedding  $\\mathbf{X} = (\\mathbf{x}_1,\\mathbf{x}_2,\\dots,\\mathbf{x}_l)$ , the code diff encoder can transformed them to  $\\mathbf{Enc} = (\\mathbf{enc}_1,\\mathbf{enc}_2,\\dots,\\mathbf{enc}_l)$ . Then we obtain the semantic vector of the code diff by pooling operation:",
+        "bbox": [
+            507,
+            621,
+            882,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\operatorname {v e c} = \\text {p o o l i n g} (\\mathbf {E n c}) = \\text {m e a n} \\left(\\mathbf {e n c} _ {1}, \\mathbf {e n c} _ {2}, \\dots , \\mathbf {e n c} _ {1}\\right) \\tag {3}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            519,
+            812,
+            880,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where mean is a dimension-wise average operation. We measure the similarity of two code diffs by cosine similarity of their semantic vectors and retrieve the most similar code diff paired with the commit message from the parallel training corpus. For each",
+        "bbox": [
+            507,
+            839,
+            882,
+            919
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "code diff, we return the first-ranked similar result. But, for the code diff in the training dataset, we return the second-ranked similar result because the first-ranked result is itself.",
+        "bbox": [
+            112,
+            84,
+            489,
+            148
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Generation module",
+        "text_level": 1,
+        "bbox": [
+            112,
+            162,
+            312,
+            175
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As shown at the bottom of Figure 1, in the generation module, we treat the retrieved commit message as an exemplar and leverage it to guide the neural network model to generate an accurate commit message. Our generation module consists of three components: three encoders, an exemplar guider, and a decoder.",
+        "bbox": [
+            112,
+            183,
+            489,
+            294
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, following Equation 1, 2, three Transformer-based encoders are adopted to obtain the representations of the input code diff  $(\\mathbf{Enc}^{\\mathbf{d}} = \\mathbf{enc}_1^d,\\mathbf{enc}_2^d,\\dots,\\mathbf{enc}_l^d)$ , the similar code diff  $(\\mathbf{Enc}^{\\mathbf{s}} = \\mathbf{enc}_1^s,\\mathbf{enc}_2^s,\\dots,\\mathbf{enc}_m^s)$ , and similar commit message  $(\\mathbf{Enc}^{\\mathbf{m}} = \\mathbf{enc}_1^m,\\mathbf{enc}_2^m,\\dots,\\mathbf{enc}_n^m)$  (step ① in Figure 1), where subscripts  $l,m,n$  are the length of the input code diff, the similar code diff, and the similar commit message, respectively.",
+        "bbox": [
+            112,
+            297,
+            489,
+            441
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Second, since the retrieved similar commit messages may not always accurately describe the content/ intent of the input code diffs even express totally wrong or irrelevant semantics. Therefore, we propose an exemplar guider which first learns the semantic similarity between the retrieved and input code diff and then leverages the information of the similar commit messages based on the learned similarity to guide the commit message generation (step ②). Mathematically, exemplar guider calculate the semantic similarity  $(\\lambda)$  between the input code diff and the similar code diff based on their representation  $\\mathbf{Enc}_l^d$  and  $\\mathbf{Enc}_m^s$  (step ② and ③):",
+        "bbox": [
+            112,
+            443,
+            489,
+            652
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\lambda = \\sigma \\left(\\mathbf {W} _ {\\mathbf {s}} \\left[ m e a n \\left(\\mathbf {E} \\mathbf {n c} ^ {d}\\right), m e a n \\left(\\mathbf {E} \\mathbf {n c} ^ {s}\\right) \\right]\\right) \\tag {4}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            164,
+            665,
+            487,
+            682
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\sigma$  is the sigmoid activation function,  $\\mathbf{W}_{\\mathrm{s}}$  is a learnable matrix, and mean is a dimension-wise average operation.",
+        "bbox": [
+            112,
+            696,
+            487,
+            744
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Third, we weight representations of code diff and similar commit message by  $1 - \\lambda$  and  $\\lambda$ , respectively and then concatenate them to obtain the final input encoding.",
+        "bbox": [
+            112,
+            746,
+            489,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\n\\mathbf {E n c} ^ {\\mathrm {d m}} = \\left[ (1 - \\lambda) * \\mathbf {E n c} ^ {\\mathrm {d}}: \\lambda * \\mathbf {E n c} ^ {\\mathrm {s}} \\right] \\tag {5}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            171,
+            822,
+            487,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, we use a Transformer-based decoder to generate the commit message. The decoder consists of multiply decoder layer and each layers includes a masked multi-head self-attention, a",
+        "bbox": [
+            112,
+            854,
+            489,
+            917
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/61acb78ade90321bc370083c319f67214cff2d3ee3a341486c82dba6a545ec22.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Training</td><td>Validation</td><td>Test</td></tr><tr><td>Java</td><td>160,018</td><td>19,825</td><td>20,159</td></tr><tr><td>C#</td><td>149,907</td><td>18,688</td><td>18,702</td></tr><tr><td>C++</td><td>160,948</td><td>20,000</td><td>20,141</td></tr><tr><td>Python</td><td>206,777</td><td>25,912</td><td>25,837</td></tr><tr><td>JavaScript</td><td>197,529</td><td>24,899</td><td>24,773</td></tr></table>",
+        "bbox": [
+            547,
+            80,
+            840,
+            171
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Statistics of the evaluation dataset.",
+        "bbox": [
+            547,
+            180,
+            842,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "multi-head cross-attention module, a FFN module and an add & norm module. Different from multi-head self-attention module in the encoder, in terms of one token, masked multi-head self-attention in the decoder can only attend to the previous tokens rather than the before and after context. In  $b$ -th cross-attention layer, the input encoding  $(\\mathbf{Enc}^{\\mathrm{dm}} = (\\mathbf{enc}_1^{\\mathrm{dm}}, \\mathbf{enc}_2^{\\mathrm{dm}}, \\dots, \\mathbf{enc}_{\\mathrm{l + m}}^{\\mathrm{dm}}))$  is queried by the output of the preceding commit message representations  $\\mathbf{Msg} = (\\mathbf{msg}_1, \\dots, \\mathbf{msg}_t)$  obtained by masked multi-head self-attention module.",
+        "bbox": [
+            507,
+            219,
+            884,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nD e c _ {\\text {h e a d} _ {i} ^ {b}} = \\sum_ {j = 1} ^ {l + m} \\alpha_ {i j} \\left(\\mathbf {W} _ {\\mathbf {V}} ^ {\\mathbf {D e c}} \\mathbf {e n c} _ {\\mathbf {j}} ^ {\\mathbf {b}}\\right) \\tag {6}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            552,
+            419,
+            880,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nD e c _ {e _ {i j}} = \\frac {\\left(\\mathbf {W} _ {\\mathbf {Q}} ^ {\\mathbf {D e c}} \\mathbf {m s g} _ {\\mathbf {j}} ^ {\\mathbf {b}}\\right) ^ {T} \\left(\\mathbf {W} _ {\\mathbf {K}} ^ {\\mathbf {D e c}} \\mathbf {e n c} _ {\\mathbf {i}} ^ {\\mathbf {b}}\\right)}{\\sqrt {d _ {k}}}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            569,
+            457,
+            836,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where  $\\alpha_{ij} = \\frac{\\exp\\text{Dec}_{ij}}{\\sum_{k=1}^{n}\\exp\\text{Dec}_{ik}}$ ,  $\\mathbf{W}_{\\mathbf{Q}}^{\\mathbf{Dec}}$ ,  $\\mathbf{W}_{\\mathbf{K}}^{\\mathbf{Dec}}$  and  $\\mathbf{W}_{\\mathbf{V}}^{\\mathbf{Dec}}$  are trainable projection matrices for queries, keys and values of the decoder layer. t is the length of preceding commit message.",
+        "bbox": [
+            507,
+            498,
+            882,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we use Equation 2 to obtain the hidden states of each decoder layer. In the last decoder layers, we employ a MLP and softmax operator to obtain the generation probability of each commit message token on the vocabulary. Then we use the cross-entropy as the loss function and apply AdamW for optimization.",
+        "bbox": [
+            507,
+            571,
+            882,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Setup",
+        "text_level": 1,
+        "bbox": [
+            507,
+            696,
+            717,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Dataset",
+        "text_level": 1,
+        "bbox": [
+            507,
+            721,
+            616,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our experiment, we use a large-scale dataset MCMD (Tao et al., 2021) with five programming languages (PLs): Java, C#, C++, Python and JavaScript. For each PL, MCMD collects commits from the top-100 starred repositories on GitHub and then filters the redundant messages (such as rollback commits) and noisy messages defined in Liu et al. (2018). Finally, to balance the size of data, they randomly sample and retain 450,000 commits for each PL. Each commit contains the code diff, the commit message, the name of the repository,",
+        "bbox": [
+            505,
+            741,
+            884,
+            919
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and the timestamp of commit, etc. To reduce the noise data in the dataset, we further filter out commits that contain multiple files or files that cannot be parsed (such as .jar, .ddl, .mp3, and .apk).",
+        "bbox": [
+            112,
+            84,
+            489,
+            149
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Data pre-processing",
+        "text_level": 1,
+        "bbox": [
+            112,
+            159,
+            319,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The code diff in MCMD are based on line-level code change. To obtain more fine-grained code change, following previous study (Panthaplackel et al., 2020), we use a sequence of span of token-level change actions to represent the code diff. Each action is structured as <action> span of tokens <action end>. There are four <action> types, namely, <keep>, <insert>, <delete>, and <replace>. <keep> means that the span of tokens are unchanged. <insert> means that adding span of tokens. <delete> means that deleting span of tokens. <replace> means that the span of tokens in the old version that will be replaced with different span of tokens in the new version. Thus, we extend <replace> to <replace old> and <replace new> to indicate the span of old and new tokens, respectively. We use difflib<sup>1</sup> to extract the sequence of code change actions.",
+        "bbox": [
+            112,
+            179,
+            489,
+            485
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Hyperparameters",
+        "text_level": 1,
+        "bbox": [
+            112,
+            495,
+            302,
+            511
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We follow (Tao et al., 2021) to set the maximum lengths of code diff and commit message to 200 and 50, respectively. We use the weight of the encoder of CodeT5-base (Wang et al., 2021b) to initialize the code diff encoders and use the decoder of CodeT5-base to initialize the decoder in Figure 1. The original vocabulary sizes of CodeT5 is 32,100. We add nine special tokens (<keep>, <keep_end>, <insert>, <insert_end>, <delete>, <delete_end>, <replace_old>, <replace_new>, and <replace_end>) and the vocabulary sizes of code and queries become 32109. For the optimizer, we use AdamW with the learning rate 2e-5. The batch size is 32. The max epoch is 20. In addition, we run the experiments 3 times with random seeds 0,1,2 and display the mean value in the paper. The experiments are conducted on a server with 4 GPUs of NVIDIA Tesla V100 and it takes about 1.2 hours each epoch.",
+        "bbox": [
+            112,
+            516,
+            489,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 Evaluation metrics",
+        "text_level": 1,
+        "bbox": [
+            112,
+            832,
+            310,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the quality of the generated messages using four metrics: BLEU (Papineni et al.,",
+        "bbox": [
+            112,
+            853,
+            489,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2002), Meteor (Banerjee and Lavie, 2005), Rouge-L (Lin, 2004), and Cider (Vedantam et al., 2015). These metrics are prevalent metrics in machine translation, text summarization, and image captioning. There are many variants of BLEU being used to measure the generated message, We choose B-Norm (the BLEU result in this paper is B-Norm), which correlates with human perception the most (Tao et al., 2021). The detailed metrics calculation can be found in Appendix.",
+        "bbox": [
+            507,
+            84,
+            884,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.5 Baselines",
+        "text_level": 1,
+        "bbox": [
+            507,
+            256,
+            628,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare RACE with four end-to-end neural-based models, two IR-based methods, two hybrid approaches which combine IR-based techniques and end-to-end neural-based methods, and three pre-trained-based models. Four end-to-end neural-based models include CommitGen (Jiang et al., 2017), CoDiSum (Xu et al., 2019), NMTGen (Loyola et al., 2017), PtrGNCMsg (Liu et al., 2019) and ATOM (Liu et al., 2020). They all train models from scratch. Two IR-based methods are NNGen (Liu et al., 2018) and Lucene (Apache, 2011), they retrieve the similar code diff based on different similarity measurements and reuse the commit message of the similar code diff as the final result. CoRec and ATOM are all hybrid models which combine the neural-based models and IR-based techniques. Three pre-trained models are CommitBERT, CodeT5-small, and CodeT5-base. They are pre-trained on the large parallel code and natural language corpus and fine-tuned on the commit message generation dataset. All baselines except Lucene, CodeT5-small and CodeT5-base are introduced in Section 2. Lucene is a traditional IR baseline, which uses TF-IDF to represent a code diff as a vector and searches the similar code diff based on the cosine similarity between two vectors. CodeT5-small and CodeT5-base are source code pre-trained models and have achieved promising results in many code-related tasks (Wang et al., 2021b). We fine-tune them on MCMD as strong baselines. In addition, we only evaluate ATOM on Java dataset as the current implementation of ATOM only supports Java.",
+        "bbox": [
+            507,
+            278,
+            884,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experimental Results",
+        "text_level": 1,
+        "bbox": [
+            507,
+            822,
+            732,
+            839
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 How does RACE perform compared with baseline approaches?",
+        "text_level": 1,
+        "bbox": [
+            507,
+            848,
+            878,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effectiveness of RACE, we conduct the experiment by comparing it with the 11",
+        "bbox": [
+            507,
+            887,
+            884,
+            919
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "page_footnote",
+        "text": "1https://docs.python.org/3/library/difflib. html",
+        "bbox": [
+            112,
+            891,
+            462,
+            917
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f136987fd0ff106574374e311b19890e76c2d01820c6a1ddb6fac2535649df1e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\">Model</td><td colspan=\"4\">Java</td><td colspan=\"4\">C#</td><td colspan=\"4\">C++</td><td colspan=\"4\">Python</td><td colspan=\"4\">JavaScript</td></tr><tr><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td></tr><tr><td rowspan=\"2\">IR-based</td><td>NNGen</td><td>19.41</td><td>12.40</td><td>25.15</td><td>1.23</td><td>22.15</td><td>14.77</td><td>26.46</td><td>1.55</td><td>13.61</td><td>9.39</td><td>18.21</td><td>0.73</td><td>16.06</td><td>10.91</td><td>21.69</td><td>0.92</td><td>18.65</td><td>12.50</td><td>24.45</td><td>1.21</td></tr><tr><td>Lucene</td><td>15.61</td><td>10.56</td><td>19.43</td><td>0.94</td><td>20.68</td><td>13.34</td><td>23.02</td><td>1.36</td><td>13.43</td><td>8.81</td><td>16.78</td><td>0.67</td><td>15.16</td><td>9.63</td><td>18.85</td><td>0.85</td><td>17.66</td><td>11.25</td><td>21.75</td><td>1.02</td></tr><tr><td rowspan=\"4\">End-to-end</td><td>CommitGen</td><td>14.07</td><td>7.52</td><td>18.78</td><td>0.66</td><td>13.38</td><td>8.31</td><td>17.44</td><td>0.63</td><td>11.52</td><td>6.98</td><td>16.75</td><td>0.45</td><td>11.02</td><td>6.43</td><td>16.64</td><td>0.42</td><td>18.67</td><td>11.88</td><td>24.10</td><td>1.08</td></tr><tr><td>CoDiSum</td><td>13.97</td><td>6.02</td><td>16.12</td><td>0.39</td><td>12.71</td><td>5.56</td><td>14.40</td><td>0.36</td><td>12.44</td><td>6.00</td><td>14.39</td><td>0.42</td><td>14.61</td><td>8.59</td><td>17.02</td><td>0.42</td><td>11.22</td><td>5.32</td><td>13.26</td><td>0.28</td></tr><tr><td>NMTGen</td><td>15.52</td><td>8.91</td><td>21.13</td><td>0.86</td><td>12.71</td><td>8.11</td><td>17.16</td><td>0.62</td><td>11.57</td><td>7.06</td><td>17.46</td><td>0.51</td><td>11.41</td><td>7.18</td><td>18.43</td><td>0.48</td><td>18.22</td><td>12.07</td><td>24.43</td><td>1.12</td></tr><tr><td>PtrGNCMsg</td><td>17.71</td><td>11.33</td><td>24.32</td><td>0.99</td><td>15.98</td><td>10.18</td><td>21.16</td><td>0.83</td><td>14.06</td><td>9.63</td><td>20.17</td><td>0.63</td><td>15.89</td><td>11.36</td><td>23.49</td><td>0.76</td><td>20.78</td><td>14.52</td><td>27.87</td><td>1.29</td></tr><tr><td rowspan=\"2\">Hybrid</td><td>ATOM</td><td>16.42</td><td>11.66</td><td>22.67</td><td>0.91</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td></tr><tr><td>CoRec</td><td>18.51</td><td>11.26</td><td>24.78</td><td>1.13</td><td>18.41</td><td>11.70</td><td>23.73</td><td>1.12</td><td>14.02</td><td>8.63</td><td>20.10</td><td>0.72</td><td>15.09</td><td>9.60</td><td>22.35</td><td>0.80</td><td>21.30</td><td>13.84</td><td>27.53</td><td>1.40</td></tr><tr><td rowspan=\"3\">Pre-trained</td><td>CommitBERT</td><td>22.32</td><td>12.63</td><td>28.03</td><td>1.42</td><td>20.67</td><td>12.31</td><td>25.76</td><td>1.25</td><td>16.16</td><td>10.05</td><td>19.90</td><td>0.94</td><td>17.29</td><td>11.31</td><td>22.36</td><td>1.01</td><td>23.40</td><td>15.64</td><td>30.51</td><td>1.54</td></tr><tr><td>CodeT5-small</td><td>22.28</td><td>14.16</td><td>29.71</td><td>1.37</td><td>18.92</td><td>11.71</td><td>24.95</td><td>1.05</td><td>16.08</td><td>11.19</td><td>21.60</td><td>0.79</td><td>17.49</td><td>12.46</td><td>24.65</td><td>0.90</td><td>21.97</td><td>14.48</td><td>28.65</td><td>1.42</td></tr><tr><td>CodeT5-base</td><td>22.76</td><td>14.57</td><td>30.23</td><td>1.43</td><td>22.21</td><td>14.51</td><td>29.08</td><td>1.33</td><td>16.73</td><td>11.69</td><td>22.86</td><td>0.85</td><td>17.99</td><td>12.74</td><td>25.27</td><td>0.96</td><td>22.87</td><td>15.12</td><td>29.81</td><td>1.50</td></tr><tr><td rowspan=\"2\">Ours</td><td rowspan=\"2\">RACE</td><td>25.66</td><td>15.46</td><td>32.02</td><td>1.76</td><td>26.33</td><td>16.37</td><td>31.31</td><td>1.84</td><td>19.13</td><td>12.55</td><td>24.52</td><td>1.14</td><td>21.79</td><td>14.68</td><td>28.35</td><td>1.40</td><td>25.55</td><td>16.31</td><td>31.79</td><td>1.84</td></tr><tr><td>↑13%</td><td>↑6%</td><td>↑6%</td><td>↑23%</td><td>↑19%</td><td>↑13%</td><td>↑8%</td><td>↑38%</td><td>↑14%</td><td>↑7%</td><td>↑7%</td><td>↑34%</td><td>↑21%</td><td>↑15%</td><td>↑12%</td><td>↑46%</td><td>↑12%</td><td>↑8%</td><td>↑7%</td><td>↑23%</td></tr><tr><td>Ablation</td><td>RACE -Guider</td><td>23.37</td><td>13.98</td><td>30.01</td><td>1.53</td><td>21.33</td><td>13.56</td><td>27.33</td><td>1.31</td><td>17.43</td><td>12.10</td><td>22.03</td><td>0.95</td><td>19.44</td><td>13.89</td><td>26.4</td><td>1.01</td><td>23.39</td><td>15.64</td><td>30.51</td><td>1.54</td></tr></table>",
+        "bbox": [
+            114,
+            80,
+            912,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Comparison of RACE with baselines under four metrics on five programming languages. Met., Rou., and Cide. are short for Meteor, Rouge-L, and Cider, respectively. All results are statistically significant (with  $p < 0.01$ ).",
+        "bbox": [
+            112,
+            300,
+            882,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "basielines including two IR-based approaches, four end-to-end neural-based approaches, two hybrid approaches, and three pre-train-based approaches in terms of four evaluation metrics. The experimental results are shown in Table 2.",
+        "bbox": [
+            112,
+            369,
+            487,
+            448
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We can see that IR-based models NNGen and Lucene generally outperform end-to-end neural models on average in terms of four metrics. It indicates that retrieved similar results can provide important information for commit message generation. CoRec, which combines the IR-based method and neural method, performs better than NNGen on  $\\mathrm{C + + }$  and JavaScript dataset but lower than NNGen on Java, C# and Python. This is because CoRec only leverages the information similar code diff at the inference stage. ATOM, which priorities the generated result of the neural-based model and retrieved result of the IR-based method, also outperforms the IR-based approach Lucene and three neural-based models CommitGen, CoDiSum, and NMTGen. Three pre-trained-based approaches outperform other baselines in terms of four metrics on average. CodeT5-base performs best among them on average. Our approach performs the best among all approaches on 5 programming languages in terms of four metrics. This is because RACE treats the retrieved similar commit message as an exemplar and leverages it to guide the neural network model to generate an accurate commit message.",
+        "bbox": [
+            115,
+            451,
+            487,
+            851
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also give an example of commit messages generated by our approach and the baselines in Figure 2. IR-based methods NNGen and Lucene can retrieve semantically similar but not completely",
+        "bbox": [
+            112,
+            854,
+            489,
+            920
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "correct commit message. Specifically, retrieved commit messages contain not only the important semantic (\"Filter out unavailable databases\") of the current code diff but also the extra information (\"Revert\"). Neural network models generally capture the action of \"add\" but fail to further understand the intend of the code diff. The hybrid model CoRec cannot generate the correct commit message either. Our model treats the retrieved result (Revert \"Filter out unavailable databases\") as an exemplar, and guides the neural network model to generate the correct commit message.",
+        "bbox": [
+            507,
+            369,
+            885,
+            562
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 What is the effectiveness of exemplar guider?",
+        "text_level": 1,
+        "bbox": [
+            507,
+            574,
+            847,
+            606
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct the ablation study to verify the effectiveness of exemplar guider module. Specifically, as shown at the bottom of Figure 1, we directly concatenated the representations of retrieved results and fed them to the decoder to generate commit messages without using the exemplar guider. As shown at the bottom of the Table 2, we can see that the performance of the ablated model (RACE-Guide) degrades in all programming languages in terms of four metrics. It demonstrates the effectiveness of our exemplar guider.",
+        "bbox": [
+            505,
+            611,
+            885,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 What is the performance when we retrieve  $k$  relevant commits?",
+        "text_level": 1,
+        "bbox": [
+            507,
+            801,
+            823,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also conduct experiments to recall  $k$  ( $k = 1, 3, 5, 7, 9$ ) most relevant commits to augment the generation model. Specifically, as shown in Figure 1 the relevance of the code diff is measured by the cosine similarity their semantic vectors obtained by",
+        "bbox": [
+            507,
+            839,
+            884,
+            919
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/df3a27eb2a9292c61967484dfc545d7580e17fa9b238f8e959d09153ba050ce1.jpg",
+        "image_caption": [
+            "Reference Filter out unavailable databases"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            127,
+            85,
+            450,
+            211
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/86d7ea444c3437930db4ea717de8ac1c91148c4ac2641c9b179b752f45bf4d67.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Baselines</td></tr><tr><td>NNGen</td><td>Revert “ Filter out unavailable databases”</td></tr><tr><td>Lucene</td><td>Revert “ filter out unavailable databases ”</td></tr><tr><td>CommitGen</td><td>Merge pull request from mistecrunch / UNK</td></tr><tr><td>NMTGen</td><td>Add &lt;unk&gt; to &lt;unk&gt;</td></tr><tr><td>PtrGNCMsg</td><td>Add support for dashboards in database</td></tr><tr><td>CoRec</td><td>Remove &lt;unk&gt;</td></tr><tr><td>CommitBERT</td><td>Add DatabaseFilter ( )</td></tr><tr><td>CodeT5-small</td><td>[database] Add databasefilter to filter all users</td></tr><tr><td>CodeT5-base</td><td>[hotfix] Adding databasefilter to core.py</td></tr><tr><td>RACE</td><td>Stage I : Revert “ Filter out unavailable databases ”Stage II : Filter out unavailable databases</td></tr></table>",
+        "bbox": [
+            127,
+            229,
+            492,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Equation 3. Then retrieved  $k$  relevant commits are encoded and fed to the exemplar guider to obtain semantic similarities by Equation 4, respectively. Finally, we weight representations of code diff and similar commit messages according to the semantic similarities and feed them to the decoder to generate commit messages step by step. The experimental results are shown in Figure 3. We can see that the performance is generally stable on different  $k$ . In our future work, we will continue to study alternatives on leveraging the information of the retrieved results, e.g., how many commits to retrieve and how to model the corresponding information.",
+        "bbox": [
+            112,
+            485,
+            489,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 Can our framework boost the performance of existing models?",
+        "text_level": 1,
+        "bbox": [
+            112,
+            705,
+            413,
+            737
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We further study whether our framework can enhance the performance of the existing Seq2Seq neural network model in commit message generation. Therefore, we adapt our framework to four Seq2Seq-based models, namely NMTGen (M1), CommitBERT (M2), CodeT5-small (M3) and CodeT5-base (M4). Specifically, we use the encoder of these models as our code diff encoder and obtain the high-dimensional semantic vectors in the retrieval module (Figure 1). In the generation module, we use the encoder of their models",
+        "bbox": [
+            112,
+            741,
+            489,
+            917
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4d214e23a6fc1e743eadac9e9166b2bfd94da310cb8e92fa792f7ee376b5cb3.jpg",
+        "image_caption": [
+            "Figure 3: Performance of models augmented with  $k$  retrieved relevant commits."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            515,
+            85,
+            884,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ddc39bfbd5f0f31491e972522e759c290281c890cdf3cad3b1005a0b64b862e.jpg",
+        "image_caption": [
+            "Figure 2: An example of generated commit messages. Reference is the developer-written commit message. The results of our approach in stage I and II are returned by the retrieved module and generation module, respectively.",
+            "Figure 4: Performance gains on four models. The original performance of the models are in yellow and gains from our framework are in green. The percentage value in each bar is the rate of improvement."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            514,
+            284,
+            878,
+            456
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "to encode input code diffs, similar code diffs, and similar commit messages. We also use the decoder of their models to generate commit messages.",
+        "bbox": [
+            507,
+            552,
+            882,
+            601
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The experimental results are shown in Figure 4, we present the performance of four original models (yellow) and gains (green) from our framework on five programming languages in terms of  $\\mathrm{BLEU}^2$  score. Overall, we can see that our framework can improve the performance of all four neural models in all programming languages. Our framework can improve the performance of the original model from  $7\\%$  to  $73\\%$ . Especially, after applying our framework, the performance of NMTGen has more than  $20\\%$  improvement on all programming languages. In addition, Our framework can boost the performance of NMTGen on BLUE, Meteor, Rouge-L, and Cider by  $43\\%$ ,  $49\\%$ ,  $33\\%$ , and  $61\\%$  on average, boost CommitBERT by  $11\\%$ ,  $9\\%$ ,  $11\\%$ , and  $12\\%$ , boost CodeT5-small by  $15\\%$ ,  $14\\%$ ,  $11\\%$ , and  $26\\%$ , and boost CodeT5-base by  $16\\%$ ,  $10\\%$ ,",
+        "bbox": [
+            507,
+            602,
+            884,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_footnote",
+        "text": "2We show results of other three metrics in Appendix due to space limitation. Our conclusions also hold.",
+        "bbox": [
+            507,
+            892,
+            882,
+            917
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ebc2cd954cae688528282d3e7f004a8bf9630cd9d2c676f4e0bfc930d03b87f6.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Informativeness</td><td>Conciseness</td><td>Expressiveness</td></tr><tr><td>CommitBERT</td><td>1.22 (±1.02)</td><td>2.03 (±1.04)</td><td>2.46 (±0.99)</td></tr><tr><td>NNGen</td><td>1.03 (±1.00)</td><td>1.74 (±1.01)</td><td>2.36 (±0.95)</td></tr><tr><td>NMTGen</td><td>0.74 (±0.92)</td><td>1.56 (±0.93)</td><td>2.11 (±0.94)</td></tr><tr><td>CoRec</td><td>1.05 (±1.09)</td><td>1.80 (±1.05)</td><td>2.43 (±0.88)</td></tr><tr><td>RACE</td><td>2.49 (±1.10)</td><td>3.08 (±0.96)</td><td>2.85 (±0.84)</td></tr></table>",
+        "bbox": [
+            114,
+            80,
+            490,
+            177
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Results of human evaluation (standard deviation in parentheses).",
+        "bbox": [
+            112,
+            186,
+            489,
+            216
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "$8\\%$ , and  $32\\%$",
+        "bbox": [
+            112,
+            241,
+            233,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 Human evaluation",
+        "text_level": 1,
+        "bbox": [
+            112,
+            273,
+            305,
+            288
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also conduct a human evaluation by following the previous works (Moreno et al., 2013; Panichella et al., 2016; Shi et al., 2021b) to evaluate the semantic similarity of the commit message generated by RACE and four baselines NNGen, NMTGen, CommitBERT, and CoRec. The four baselines are IR-based, end-to-end neural network-based, hybrid, and pre-trained-based approaches, respectively. We randomly choose 50 code diff from the testing sets and their commit message generated by four approaches. Finally, we sample  $250 < \\text{code diff}$ , commit message> pairs to score. Specifically, we invite 4 volunteers with excellent English ability and more than three years of software development experience. Each volunteer is asked to assign scores from 0 to 4 (the higher the better) to the generated commit message from the three aspects: Informativeness (the amount of important information about the code diff reflected in the commit message), Conciseness (the extend of extraneous information included in the commit message), and Expressiveness (grammaticality and fluency). Each pair is evaluated by four volunteers, and the final score is the average of them.",
+        "bbox": [
+            112,
+            294,
+            489,
+            680
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To verify the agreement among the volunteers, we calculate the Krippendorff's alpha (Hayes and Krippendorff, 2007) and Kendall rank correlation coefficient (Kendall's Tau) values (Kendall, 1945). The value of Krippendorff's alpha is 0.90 and the values of pairwise Kendall's Tau range from 0.73 to 0.95, which indicates that there is a high degree of agreement between the 4 volunteers and that scores are reliable. Table 3 shows the result of human evaluation. RACE is better than other approaches in Informative, Conciseness, and Expressiveness, which means that our approach tends to generate concise and readable commit messages with more",
+        "bbox": [
+            112,
+            683,
+            489,
+            891
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "comprehensive semantics. In addition, we confirm the superiority of our approach using Wilcoxon signed-rank tests (Wilcoxon et al., 1970) for the human evaluation. Results show that the improvement of RACE over other approaches is statistically significant with all p-values smaller than 0.05 at  $95\\%$  confidence level.",
+        "bbox": [
+            507,
+            84,
+            884,
+            197
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion",
+        "text_level": 1,
+        "bbox": [
+            507,
+            210,
+            640,
+            225
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This paper proposes a new retrieval-augmented neural commit message generation method, which treats the retrieved similar commit message as an exemplar and uses it to guide the neural network model to generate an accurate and readable commit message. Extensive experimental results demonstrate that our approach outperforms recent baselines and our framework can significantly boost the performance of four neural network models. Our data, source code and Appendix are available at https://github.com/DeepSoftwareAnalytics/RACE.",
+        "bbox": [
+            507,
+            237,
+            884,
+            430
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limitations",
+        "text_level": 1,
+        "bbox": [
+            509,
+            445,
+            615,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have identified the following main limitations:",
+        "bbox": [
+            507,
+            472,
+            880,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Programming Languages. We only conduct experiments on five programming languages. Although in principle, our framework is not specifically designed for certain languages, models perform differently in different programming languages. Therefore, more experiments are needed to confirm the generality of our framework. In the future, we will extend our study to other programming languages.",
+        "bbox": [
+            507,
+            489,
+            882,
+            633
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Code base. Compared with purely neural network-based models, our method needs a code base to retrieve the most similar example from that. This limitation is inherited from IR-based techniques.",
+        "bbox": [
+            507,
+            634,
+            880,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Training Time. In addition to modeling the information of input code diffs, our model needs to retrieve similar diffs and encode them. Thus, our model takes a long time to train (about 35 hours to train the model).",
+        "bbox": [
+            507,
+            715,
+            880,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Long Code Diffs. Longer code diffs may contain more complex semantics or behaviors. Long diffs (over 512 tokens) are truncated in our approach and some information would be lost. In our future work, we will design mechanisms to better handle long diffs.",
+        "bbox": [
+            507,
+            797,
+            880,
+            892
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "page_footnote",
+        "text": "3The result can be found in 1-4 of Appendix",
+        "bbox": [
+            134,
+            903,
+            408,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "page_footnote",
+        "text": "Available in Appendix",
+        "bbox": [
+            529,
+            903,
+            678,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement",
+        "text_level": 1,
+        "bbox": [
+            114,
+            84,
+            278,
+            99
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank reviewers for their valuable comments on this work. This research was supported by National Key R&D Program of China (No. 2017YFA0700800). We would like to thank Jiaqi Guo and Wenchao Gu for their valuable suggestions and feedback during the work discussion process. We also thank the participants of our human evaluation for their time.",
+        "bbox": [
+            112,
+            109,
+            489,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References",
+        "text_level": 1,
+        "bbox": [
+            114,
+            263,
+            213,
+            279
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Apache. 2011. Apache lucene.",
+            "Satanjeev Banerjee and Alon Lavie. 2005. METEOR: an automatic metric for MT evaluation with improved correlation with human judgments. In IEEvaluation@ACL.",
+            "Mike Barnett, Christian Bird, João Brunet, and Shuvendu K. Lahiri. 2015. Helping developers help themselves: Automatic decomposition of code review changesets. In ICSE (1), pages 134-144. IEEE Computer Society.",
+            "Raymond P. L. Buse and Westley Weimer. 2010. Automatically documenting program changes. In ASE, pages 33-42. ACM.",
+            "Luis Fernando Cortes-Coy, Mario Linares Vásquez, Jairo Aponte, and Denys Poshyvanyk. 2014. On automatically generating commit messages via summarization of source code changes. In SCAM, pages 275-284. IEEE Computer Society.",
+            "Martin Dias, Alberto Bacchelli, Georgios Gousios, Damien Cassou, and Stephane Ducasse. 2015. Untangling fine-grained code changes. In SANER, pages 341-350. IEEE Computer Society.",
+            "Jinhao Dong, Yiling Lou, Qihao Zhu, Zeyu Sun, Zhilin Li, Wenjie Zhang, and Dan Hao. 2022. Fira: Fine-grained graph-based code change representation for automated commit message generation.",
+            "Lun Du, Xiaozhou Shi, Yanlin Wang, Ensheng Shi, Shi Han, and Dongmei Zhang. 2021. Is a single model enough? mucos: A multi-model ensemble learning approach for semantic code search. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management, pages 2994-2998.",
+            "Robert Dyer, Hoan Anh Nguyen, Hridesh Rajan, and Tien N. Nguyen. 2013. Boa: a language and infrastructure for analyzing ultra-large-scale software repositories. In ICSE, pages 422-431. IEEE Computer Society.",
+            "Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020."
+        ],
+        "bbox": [
+            115,
+            287,
+            489,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Codebert: A pre-trained model for programming and natural languages. In EMNLP (Findings), volume EMNLP 2020 of Findings of ACL, pages 1536-1547. Association for Computational Linguistics.",
+            "Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. 2018. Deep code search. In ICSE, pages 933-944. ACM.",
+            "Andrew F Hayes and Klaus Krippendorff. 2007. Answering the call for a standard reliability measure for coding data. Communication methods and measures, 1(1):77-89.",
+            "Yuan Huang, Nan Jia, Hao-Jie Zhou, Xiangping Chen, Zibin Zheng, and Mingdong Tang. 2020. Learning human-written commit messages to document code changes. J. Comput. Sci. Technol., 35(6):1258-1277.",
+            "Yuan Huang, Qiaoyang Zheng, Xiangping Chen, Yingfei Xiong, Zhiyong Liu, and Xiaonan Luo. 2017. Mining version control system for automatically generating commit comment. In ESEM, pages 414-423. IEEE Computer Society.",
+            "Siyuan Jiang, Ameer Armaly, and Collin McMillan. 2017. Automatically generating commit messages from diffs using neural machine translation. In ASE.",
+            "Tae Hwan Jung. 2021. Commitbert: Commit message generation using pre-trained programming language model. In Proceedings of the 1st Workshop on Natural Language Processing for Programming (NLP4Prog 2021), pages 26-33.",
+            "Maurice G Kendall. 1945. The treatment of ties in ranking problems. Biometrika, 33(3):239-251.",
+            "Patrick S. H. Lewis, Ethan Perez, Aleksandra Pik-tus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Roektaschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive NLP tasks. In NeurIPS.",
+            "Chin-Yew Lin. 2004. ROUGE: A package for automatic evaluation of summaries. In Text Summarization Branches Out.",
+            "Qin Liu, Zihe Liu, Hongming Zhu, Hongfei Fan, Bowen Du, and Yu Qian. 2019. Generating commit messages from diffs using pointer-generator network. In MSR, pages 299-309. IEEE / ACM.",
+            "Shangqing Liu, Cuiyun Gao, Sen Chen, Lun Yiu Nie, and Yang Liu. 2020. ATOM: commit message generation based on abstract syntax tree and hybrid ranking. TSE, PP:1-1.",
+            "Zhongxin Liu, Xin Xia, Ahmed E. Hassan, David Lo, Zhenchang Xing, and Xinyu Wang. 2018. Neural-machine-translation-based commit message generation: how far are we? In ASE, pages 373-384. ACM.",
+            "Ilya Loshchilov and Frank Hutter. 2019. Decoupled weight decay regularization. In ICLR."
+        ],
+        "bbox": [
+            510,
+            85,
+            884,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Pablo Loyola, Edison Marrese-Taylor, and Yutaka Matsuo. 2017. A neural architecture for generating natural language descriptions from source code changes. In ACL (2), pages 287-292. Association for Computational Linguistics.",
+            "Laura Moreno, Jairo Aponte, Giriprasad Sridhara, Andrian Marcus, Lori L. Pollock, and K. Vijay-Shanker. 2013. Automatic generation of natural language summaries for java classes. In ICPC, pages 23-32. IEEE Computer Society.",
+            "Lun Yiu Nie, Cuiyun Gao, Zhicong Zhong, Wai Lam, Yang Liu, and Zenglin Xu. 2021. Coregen: Contextualized code representation learning for commit message generation. Neurocomputing, 459:97-107.",
+            "Sebastiano Panichella, Annibale Panichella, Moritz Beller, Andy Zaidman, and Harald C. Gall. 2016. The impact of test case summaries on bug fixing performance: an empirical investigation. In ICSE, pages 547-558. ACM.",
+            "Sheena Panthaplackel, Pengyu Nie, Milos Gligoric, Junyi Jessy Li, and Raymond J. Mooney. 2020. Learning to update natural language comments based on code changes. In ACL, pages 1853-1868. Association for Computational Linguistics.",
+            "Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. Bleu: a method for automatic evaluation of machine translation. In ACL.",
+            "Jinfeng Shen, Xiaobing Sun, Bin Li, Hui Yang, and Jiajun Hu. 2016. On automatic summarization of what and why information in source code changes. In COMPSAC, pages 103-112. IEEE Computer Society.",
+            "Ensheng Shi, Wenchao Gub, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2022a. Enhancing semantic code search with multimodal contrastive learning and soft data augmentation. arXiv preprint arXiv:2204.03293.",
+            "Ensheng Shi, Yanlin Wang, Lun Du, Junjie Chen, Shi Han, Hongyu Zhang, Dongmei Zhang, and Hongbin Sun. 2022b. On the evaluation of neural code summarization. In ICSE.",
+            "Ensheng Shi, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2021a. Cast: Enhancing code summarization with hierarchical splitting and reconstruction of abstract syntax trees. In EMNLP.",
+            "Ensheng Shi, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2021b. CAST: enhancing code summarization with hierarchical splitting and reconstruction of abstract syntax trees. In EMNLP (1), pages 4053-4062. Association for Computational Linguistics."
+        ],
+        "bbox": [
+            115,
+            85,
+            489,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "Wei Tao, Yanlin Wang, Ensheng Shi, Lun Du, Shi Han, Hongyu Zhang, Dongmei Zhang, and Wenqiang Zhang. 2021. On the evaluation of commit message generation models: An experimental study. In ICSME.",
+            "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In NIPS, pages 5998-6008.",
+            "Ramakrishna Vedantam, C. Lawrence Zitnick, and Devi Parikh. 2015. Cider: Consensus-based image description evaluation. In CVPR.",
+            "Haoye Wang, Xin Xia, David Lo, Qiang He, Xinyu Wang, and John Grundy. 2021a. Context-aware retrieval-based deep commit message generation. ACM Trans. Softw. Eng. Methodol., 30(4):56:1-56:30.",
+            "Yanlin Wang, Lun Du, Ensheng Shi, Yuxuan Hu, Shi Han, and Dongmei Zhang. 2020. Cocogum: Contextual code summarization with multi-relational gnn on ums. Technical report, Microsoft, MSR-TR-2020-16. [Online].",
+            "Yue Wang, Weishi Wang, Shafiq R. Joty, and Steven C. H. Hoi. 2021b. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. In EMNLP (1), pages 8696-8708. Association for Computational Linguistics.",
+            "Bolin Wei, Yongmin Li, Ge Li, Xin Xia, and Zhi Jin. 2020. Retrieve and refine: exemplar-based neural comment generation. In 2020 35th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 349-360. IEEE.",
+            "Frank Wilcoxon, SK Katti, and Roberta A Wilcox. 1970. Critical values and probability levels for the wilcoxon rank sum test and the wilcoxon signed rank test. Selected tables in mathematical statistics, 1:171-259.",
+            "Shengbin Xu, Yuan Yao, Feng Xu, Tianxiao Gu, Hanghang Tong, and Jian Lu. 2019. Commit message generation for source code changes. In *IJCAI*, pages 3975-3981. ijcai.org.",
+            "HongChien Yu, Chenyan Xiong, and Jamie Callan. 2021. Improving query representations for dense retrieval with pseudo relevance feedback. In CIKM, pages 3592-3596. ACM.",
+            "Jian Zhang, Xu Wang, Hongyu Zhang, Hailong Sun, and Xudong Liu. 2020. Retrieval-based neural source code summarization. In ICSE."
+        ],
+        "bbox": [
+            510,
+            85,
+            880,
+            829
+        ],
+        "page_idx": 10
+    }
+]

2203.02xxx/2203.02700/3d69ca7f-39a5-4c99-b9df-bcb921fe9d04_model.json

@@ -0,0 +1,2048 @@
+[
+    [
+        {
+            "type": "aside_text",
+            "bbox": [
+                0.023,
+                0.313,
+                0.061,
+                0.726
+            ],
+            "angle": 270,
+            "content": "arXiv:2203.02700v3 [cs.SE] 22 Oct 2022"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.194,
+                0.08,
+                0.804,
+                0.1
+            ],
+            "angle": 0,
+            "content": "RACE: Retrieval-Augmented Commit Message Generation"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.293,
+                0.107,
+                0.714,
+                0.124
+            ],
+            "angle": 0,
+            "content": "Ensheng Shi\\(^{a}\\) Yanlin Wang\\(^{b,\\S,\\dagger}\\) Wei Tao\\(^{c}\\) Lun Du\\(^{d}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.248,
+                0.124,
+                0.755,
+                0.141
+            ],
+            "angle": 0,
+            "content": "Hongyu Zhang<sup>e</sup> Shi Hand Dongmei Zhang<sup>d</sup> Hongbin Sun<sup>a,§</sup>"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.15,
+                0.141,
+                0.853,
+                0.158
+            ],
+            "angle": 0,
+            "content": "\\(^{a}\\)Xi'an Jiaotong University \\(^{b}\\)School of Software Engineering, Sun Yat-sen University"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.201,
+                0.158,
+                0.802,
+                0.174
+            ],
+            "angle": 0,
+            "content": "\\(^{c}\\)Fudan University \\(^{d}\\)Microsoft Research \\(^{e}\\)The University of Newcastle"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.251,
+                0.176,
+                0.753,
+                0.19
+            ],
+            "angle": 0,
+            "content": "s1530129650@stu.xjtu.edu.cn, hsun@mail.xjtu.edu.cn"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.258,
+                0.192,
+                0.744,
+                0.207
+            ],
+            "angle": 0,
+            "content": "wangylin36@mail.sysu.edu.cn，wtao18@fudan.edu.cn"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.301,
+                0.209,
+                0.705,
+                0.223
+            ],
+            "angle": 0,
+            "content": "{lun.du, shihan, dongmeiz}@microsoft.com"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.355,
+                0.225,
+                0.649,
+                0.24
+            ],
+            "angle": 0,
+            "content": "hongyu.zhang@newcastle.edu.au"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.261,
+                0.253,
+                0.341,
+                0.267
+            ],
+            "angle": 0,
+            "content": "Abstract"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.145,
+                0.28,
+                0.461,
+                0.662
+            ],
+            "angle": 0,
+            "content": "Commit messages are important for software development and maintenance. Many neural network-based approaches have been proposed and shown promising results on automatic commit message generation. However, the generated commit messages could be repetitive or redundant. In this paper, we propose RACE, a new retrieval-augmented neural commit message generation method, which treats the retrieved similar commit as an exemplar and leverages it to generate an accurate commit message. As the retrieved commit message may not always accurately describe the content/intent of the current code diff, we also propose an exemplar guider, which learns the semantic similarity between the retrieved and current code diff and then guides the generation of commit message based on the similarity. We conduct extensive experiments on a large public dataset with five programming languages. Experimental results show that RACE can outperform all baselines. Furthermore, RACE can boost the performance of existing Seq2Seq models in commit message generation. Our data and source code are available at https://github.com/DeepSoftwareAnalytics/RACE."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.115,
+                0.675,
+                0.26,
+                0.689
+            ],
+            "angle": 0,
+            "content": "1 Introduction"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.7,
+                0.49,
+                0.86
+            ],
+            "angle": 0,
+            "content": "In software development and maintenance, source code is frequently changed. In practice, code changes are often documented as natural language commit messages, which summarize what (content) the code changes are or why (intent) the code is changed (Buse and Weimer, 2010; Cortes-Coy et al., 2014). High-quality commit messages are essential to help developers understand the evolution of software without diving into implementation details, which can save a large amount of"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.254,
+                0.885,
+                0.463
+            ],
+            "angle": 0,
+            "content": "time and effort in software development and maintenance (Dias et al., 2015; Barnett et al., 2015). However, it is difficult to write high-quality commit messages due to lack of time, clear motivation, or experienced skills. Even for seasoned developers, it still poses a considerable amount of extra workload to write a concise and informative commit message for massive code changes (Nie et al., 2021). It is also reported that around \\(14\\%\\) of commit messages over 23,000 projects in SourceForge are left empty (Dyer et al., 2013). Thus, automatically generating commit messages becomes an important task."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.469,
+                0.885,
+                0.92
+            ],
+            "angle": 0,
+            "content": "Over the years, many approaches have been proposed to automatically generate commit messages. Early studies (Shen et al., 2016; Cortes-Coy et al., 2014) are mainly based on predefined rules or templates, which may not cover all situations or comprehensively infer the intentions behind code changes. Later, some studies (Liu et al., 2018; Huang et al., 2017, 2020) adopt information retrieval (IR) techniques to reuse commit messages of similar code changes. They can take advantage of similar examples, but the reused commit messages might not correctly describe the content/intent of the current code change. Recently, some Seq2Seq-based neural network models (Loyola et al., 2017; Jiang et al., 2017; Xu et al., 2019; Liu et al., 2019; Jung, 2021) have been proposed to understand code diffs and generate the high-quality commit messages. These approaches show promising performance, but they tend to generate high-frequency and repetitive tokens and the generated commit messages have the problem of insufficient information and poor readability (Wang et al., 2021a; Liu et al., 2018). Some studies (Liu et al., 2020; Wang et al., 2021a) also explore the combination of neural-based and IR-based techniques. Liu et al. (2020) propose an approach to rank the retrieved commit message (obtained by a simple IR-based model) and the generated commit message (ob-"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.114,
+                0.868,
+                0.488,
+                0.892
+            ],
+            "angle": 0,
+            "content": "\\(^{\\S}\\) Yanlin Wang and Hongbin Sun are the corresponding authors."
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.114,
+                0.893,
+                0.487,
+                0.918
+            ],
+            "angle": 0,
+            "content": "\\(^{\\dagger}\\)Work done during the author's employment at Microsoft Research Asia"
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.114,
+                0.868,
+                0.488,
+                0.918
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.085,
+                0.49,
+                0.198
+            ],
+            "angle": 0,
+            "content": "tained by a neural network model). Wang et al. (2021a) propose to use the similar code diff as auxiliary information in the inference stage, while the model is not trained to learn how to effectively utilize the information of retrieval results. Therefore, both of them fail to take advantage of the information of retrieved similar results well."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.117,
+                0.205,
+                0.492,
+                0.64
+            ],
+            "angle": 0,
+            "content": "In this paper, we propose a novel model RACE (Retrieval-Augmented Commit mEssay generation), which retrieves a similar commit message as an exemplar, guides the neural model to learn the content of the code diff and the intent behind the code diff, and generates the readable and informative commit message. The key idea of our approach is retrieval and augmentation. Specifically, we first train a code diff encoder to learn the semantics of code diffs and encode the code diff into high-dimensional semantic space. Then, we retrieve the semantically similar code diff paired with the commit message on a large parallel corpus based on the similarity measured by vectors' distance. Next, we treat the similar commit message as an exemplar and leverage it to guide the neural-based models to generate an accurate commit message. However, the retrieved commit messages may not accurately describe the content/intent of current code diffs and may even contain wrong or irrelevant information. To avoid the retrieved samples dominating the processing of commit message generation, we propose an exemplar guider, which first learns the semantic similarity between the retrieved and current code diff and then leverages the information of the exemplar based on the learned similarity to guide the commit message generation."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.646,
+                0.492,
+                0.921
+            ],
+            "angle": 0,
+            "content": "To evaluate the effectiveness of RACE, we conduct experiments on a large-scale dataset MCMD (Tao et al., 2021) with five programming language (Java, C#, C++, Python and JavaScript) and compare RACE with 11 state-of-the-art approaches. Experimental results show that: (1) RACE significantly outperforms existing state-of-the-art approaches in terms of four metrics (BLUE, Meteor, Rouge-L and Cider) on the commit message generation. (2) RACE can boost the performance of existing Seq2Seq models in commit message generation. For example, it can improve the performance of NMTGen (Loyola et al., 2017), CommitBERT (Jung, 2021), CodeT5-small (Wang et al., 2021b) and CodeT5-base (Wang et al., 2021b) by \\(43\\%\\), \\(11\\%\\), \\(15\\%\\), and \\(16\\%\\) on average in terms of BLEU, respectively. In addition,"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.085,
+                0.882,
+                0.116
+            ],
+            "angle": 0,
+            "content": "we also conduct human evaluation to confirm the effectiveness of RACE."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.117,
+                0.882,
+                0.149
+            ],
+            "angle": 0,
+            "content": "We summarize the main contributions of this paper as follows:"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.532,
+                0.159,
+                0.884,
+                0.255
+            ],
+            "angle": 0,
+            "content": "- We propose a retrieval-augmented neural commit message generation model, which treats the retrieved similar commit as an exemplar and leverages it to guide neural network model to generate informative and readable commit messages."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.532,
+                0.265,
+                0.885,
+                0.344
+            ],
+            "angle": 0,
+            "content": "- We apply our retrieval-augmented framework to four existing neural network-based approaches (NMTGen, CommitBERT, CodeT5-small, and CodeT5-base) and greatly boost their performance."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.532,
+                0.355,
+                0.884,
+                0.435
+            ],
+            "angle": 0,
+            "content": "- We perform extensive experiments including human evaluation on a large multi-programming-language dataset and the results confirm the effectiveness of our approach over state-of-the-art approaches."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.532,
+                0.159,
+                0.885,
+                0.435
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.51,
+                0.444,
+                0.667,
+                0.459
+            ],
+            "angle": 0,
+            "content": "2 Related Work"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.469,
+                0.885,
+                0.629
+            ],
+            "angle": 0,
+            "content": "Code intelligence, which leverages machine learning especially deep learning-based method to understand source code, is an emerging topic and has obtained the promising results in many software engineering tasks, such as code summarization (Zhang et al., 2020; Shi et al., 2021a, 2022b; Wang et al., 2020) and code search (Gu et al., 2018; Du et al., 2021; Shi et al., 2022a). Among them, commit message generation plays an important role in the software evolution."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.63,
+                0.884,
+                0.887
+            ],
+            "angle": 0,
+            "content": "In early work, information retrieval techniques are introduced to commit message generation (Liu et al., 2018; Huang et al., 2017, 2020). For instance, ChangeDoc (Huang et al., 2020) retrieves the most similar commits according to the syntax or semantics in the code diff and reuses commit messages of similar code diffs. NNGen (Liu et al., 2018) is a simple yet effective retrieval-based method using the nearest neighbor algorithm. It firstly recalls the top-k similar code diffs in the parallel corpus based on cosine similarity between bag-of-words vectors of code diffs. Then select the most similar result based on BLEU scores between each of them (topk results) and the input code diff. These approaches can reuse similar examples and the reused commit messages are usually readable and understandable."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.509,
+                0.888,
+                0.884,
+                0.919
+            ],
+            "angle": 0,
+            "content": "Recently, many neural-based approaches (Loyola et al., 2017; Jiang et al., 2017; Xu et al., 2019;"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.117,
+                0.085,
+                0.49,
+                0.455
+            ],
+            "angle": 0,
+            "content": "Liu et al., 2019, 2020; Jung, 2021; Dong et al., 2022; Nie et al., 2021; Wang et al., 2021a) have been used to learn the semantic of code diffs and translate them into commit messages. For example, NMTGen (Loyola et al., 2017) and CommitGen (Jiang et al., 2017) treat the code diffs as plain texts and adopt the Seq2Seq neural network with different attention mechanisms to translate them into commit messages. CoDiSum (Xu et al., 2019) extracts both code structure and code semantics from code diffs and jointly models them with a multi-layer bidirectional GRU to better learn the representations of code diffs. PtrGNCMsg (Liu et al., 2019) incorporates the pointer-generator network into the Seq2Seq model to handle out-of-vocabulary (OOV) words. CommitBERT leverage CodeBERT (Feng et al., 2020), a pre-trained language model for source code, to learn the semantic representations of code diffs and adopt a Transformer-based (Vaswani et al., 2017) decoder to generate the commit message. These approaches show promising results on the generation of commit messages."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.117,
+                0.469,
+                0.488,
+                0.919
+            ],
+            "angle": 0,
+            "content": "Recently, introducing retrieved relevant results into the training process has been found useful in most generation tasks (Lewis et al., 2020; Yu et al., 2021; Wei et al., 2020). Some studies (Liu et al., 2020; Wang et al., 2021a) also explore the combination of neural-based models and IR-based techniques to generate commit messages. ATOM (Liu et al., 2020) ensembles the neural-based model and the IR-based technique through the hybrid ranking. Specifically, it uses BiLSTM to encode ASTs paths extracted from ASTs of code diffs and adopt a decoder to generate commit messages. It also uses TF-IDF technique to represent code diffs as vectors and retrieves the most similar commit message based on cosine similarity. The generated and retrieved commit messages are finally prioritized by a hybrid ranking module. CoRec (Wang et al., 2021a) is also a hybrid model and only considers the retrieved result during the inference. Specifically, at the training stage, they use an encoder-decoder neural model to encode the input code diffs by an encoder and generate commit messages by a decoder. At the inference stage, they first use the trained encoder to retrieve the most similar code diff from the training set. Then they reuse a trained encoder-decoder to encode the input and retrieved code diff, combine the probability distributions (obtained by two decoders) of each word, and generate"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.512,
+                0.085,
+                0.885,
+                0.23
+            ],
+            "angle": 0,
+            "content": "the final commit message step by step. In summary, ATOM does not learn to refine the retrieved results or the generated results, and CoRec is not trained to utilize the information of retrieval results. Therefore, both of them fail to take full advantage of the retrieved similar results. In this paper, we treat the retrieved similar commit as an exemplar and train the model to leverage the exemplar to enhance commit message generation."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.512,
+                0.244,
+                0.715,
+                0.261
+            ],
+            "angle": 0,
+            "content": "3 Proposed Approach"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.512,
+                0.271,
+                0.885,
+                0.448
+            ],
+            "angle": 0,
+            "content": "The overview of RACE is shown in Figure 1. It includes two modules: retrieval module and generation module. Specifically, RACE firstly retrieves the most semantically similar code diff paired with the commit message from the large parallel training corpus. The semantic similarity between two code diffs is measured by the cosine similarity of vectors obtained by a code diff encoder. Next, RACE treats the retrieved commit message as an example and uses it to guide the neural network to generate an understandable and concise commit message."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.512,
+                0.461,
+                0.691,
+                0.476
+            ],
+            "angle": 0,
+            "content": "3.1 Retrieval module"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.512,
+                0.484,
+                0.885,
+                0.675
+            ],
+            "angle": 0,
+            "content": "In this module, we aim to retrieve the most semantically similar result. Specifically, we first train an encoder-decoder neural network on the large commit message generation dataset. The encoder is used to learn the semantics of code diffs and encode code diffs into a high-dimension semantic space. Then we retrieve the most semantically similar code diff paired with the commit message from the large parallel training corpus. The semantic similarity between two code diffs is measured by the cosine similarity of vectors obtained by a well-trained code diff encoder."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.512,
+                0.678,
+                0.885,
+                0.87
+            ],
+            "angle": 0,
+            "content": "Recently, encoder-decoder neural network models (Loyola et al., 2017; Jiang et al., 2017; Jung, 2021), which leverage an encoder to learn the semantic of code diff and employ a decoder to generate the commit message, have shown their superiority in the understanding of code offs and commit messages generation. To enable the code diff encoder to understand the semantics of code offs, we train it with a commit message generator on a large commit message generation dataset, which consists of about 0.9 million <code diff, commit message> pairs."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.512,
+                0.872,
+                0.884,
+                0.919
+            ],
+            "angle": 0,
+            "content": "To capture long-range dependencies (e.g. a variable is initialized before the changed line) and more contextual information of code diffs, we em"
+        }
+    ],
+    [
+        {
+            "type": "image",
+            "bbox": [
+                0.197,
+                0.085,
+                0.805,
+                0.187
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.198,
+                0.19,
+                0.805,
+                0.315
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.113,
+                0.326,
+                0.885,
+                0.37
+            ],
+            "angle": 0,
+            "content": "Figure 1: The architecture of RACE. It includes two modules: retrieval module and generation module. The retrieval module is used to retrieve the most similar code diff and commit message. The generation module leverages the retrieved result to enhance the performance of neural network models."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.394,
+                0.49,
+                0.62
+            ],
+            "angle": 0,
+            "content": "ploy a Transformer-based encoder to learn the semantic representations of input code diffs. As shown in Figure 1, a Transformer-based encoder is stacked with multiple encoder layers. Each layer consists of four parts, namely, a multi-head self-attention module, a relative position embedding module, a feed forward network (FFN) and an add & norm module. In \\( b \\)-th attention head, the input \\( \\mathbf{X}^{\\mathrm{b}} = (\\mathbf{x}_1^{\\mathrm{b}},\\mathbf{x}_2^{\\mathrm{b}},\\dots,\\mathbf{x}_1^{\\mathrm{b}}) \\) (where \\( \\mathbf{X}^{\\mathrm{b}} = \\mathbf{X}[(b - 1)*head_{dim}:b*head_{dim}] \\), \\( \\mathbf{X} \\) is the sequence of code diff embedding, \\( head_{dim} \\) is the dimension of each head and \\( l \\) is the input sequence length.) is transformed to \\( (\\mathbf{Head}^{b} = \\mathbf{head}_{1}^{\\mathrm{b}},\\mathbf{head}_{2}^{\\mathrm{b}},\\dots,\\mathbf{head}_{l}^{\\mathrm{b}}) \\) by:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.175,
+                0.627,
+                0.486,
+                0.667
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {h e a d} _ {\\mathrm {i}} ^ {\\mathrm {b}} = \\sum_ {j = 1} ^ {l} \\alpha_ {i j} \\left(\\mathbf {W} _ {\\mathbf {V}} \\mathbf {x} _ {\\mathrm {j}} ^ {\\mathrm {b}} + \\mathbf {p} _ {\\mathrm {i j}} ^ {\\mathbf {V}}\\right) \\tag {1}\n\\]"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.205,
+                0.665,
+                0.425,
+                0.696
+            ],
+            "angle": 0,
+            "content": "\\[\ne _ {i j} = \\frac {\\left(\\mathbf {W _ {Q}} \\mathbf {x _ {i} ^ {b}}\\right) ^ {T} \\left(\\mathbf {W _ {K}} \\mathbf {x _ {j} ^ {b}} + \\mathbf {p _ {i j} ^ {K}}\\right)}{\\sqrt {d _ {k}}}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.701,
+                0.489,
+                0.785
+            ],
+            "angle": 0,
+            "content": "where \\(\\alpha_{ij} = \\frac{\\exp e_{ij}}{\\sum_{k=1}^{n}\\exp e_{ik}}\\), \\(\\mathbf{W}_{\\mathbf{Q}}\\), \\(\\mathbf{W}_{\\mathbf{K}}\\) and \\(\\mathbf{W}_{\\mathbf{V}}\\) are learnable matrix for queries, keys and values. \\(d_k\\) is the dimension of queries and keys; \\(\\mathbf{p}_{\\mathbf{ij}}^{\\mathbf{K}}\\) and \\(\\mathbf{p}_{\\mathbf{ij}}^{\\mathbf{V}}\\) are relative positional representations for positions \\(i\\) and \\(j\\)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.786,
+                0.49,
+                0.864
+            ],
+            "angle": 0,
+            "content": "The outputs of all heads are concatenated and then fed to the FFN modules which is a multi-layer perception. The add & norm operation are employed after the multi-head attention and FFN modules. The calculations are as follows:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.15,
+                0.87,
+                0.488,
+                0.906
+            ],
+            "angle": 0,
+            "content": "\\[\n\\begin{array}{l} \\mathbf {H e a d} = C o n c a t \\left(\\mathbf {H e a d} ^ {\\mathbf {1}}, \\mathbf {H e a d} ^ {\\mathbf {d}}, \\mathbf {H e a d} ^ {\\mathbf {B}}\\right) \\\\ \\mathbf {H i d} = a d d \\& n o r m (\\mathbf {H e a d}, \\mathbf {X}) \\end{array} \\tag {2}\n\\]"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.163,
+                0.908,
+                0.432,
+                0.922
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {E n c} = a d d \\& n o r m (\\mathbf {F F N} (\\mathbf {H i d}), \\mathbf {H i d})\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.394,
+                0.885,
+                0.523
+            ],
+            "angle": 0,
+            "content": "where \\(add\\&norm(\\mathbf{A_1},\\mathbf{A_2}) = LN(\\mathbf{A_1} + \\mathbf{A_2})\\) \\(B\\) is the number of heads and \\(LN\\) is layer normalization. The final output of encoder is sent to Transformer-based decoder to generate the commit message step by step. We use cross-entropy as loss function and adopt AdamW (Loshchilov and Hutter, 2019) to optimize the parameters of the code diff encoder and the decoder at the top of Figure 1."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.524,
+                0.884,
+                0.621
+            ],
+            "angle": 0,
+            "content": "Next, the retrieval module is used to retrieve the most similar result from a large parallel training corpus. We firstly use the above code diff encoder to map code diffs into a high-dimensional latent space and retrieve the most similar example based on cosine similarity."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.623,
+                0.884,
+                0.799
+            ],
+            "angle": 0,
+            "content": "Specifically, after being trained in the commit message generation dataset, the code diff encoder can capture the semantic of code diff well. We use well-trained code diff encoder following a mean-pooling operation to map the code diff into a high dimensional space. Mathematically, given the input code diff embedding \\(\\mathbf{X} = (\\mathbf{x}_1,\\mathbf{x}_2,\\dots,\\mathbf{x}_l)\\), the code diff encoder can transformed them to \\(\\mathbf{Enc} = (\\mathbf{enc}_1,\\mathbf{enc}_2,\\dots,\\mathbf{enc}_l)\\). Then we obtain the semantic vector of the code diff by pooling operation:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.52,
+                0.813,
+                0.881,
+                0.838
+            ],
+            "angle": 0,
+            "content": "\\[\n\\operatorname {v e c} = \\text {p o o l i n g} (\\mathbf {E n c}) = \\text {m e a n} \\left(\\mathbf {e n c} _ {1}, \\mathbf {e n c} _ {2}, \\dots , \\mathbf {e n c} _ {1}\\right) \\tag {3}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.84,
+                0.884,
+                0.92
+            ],
+            "angle": 0,
+            "content": "where mean is a dimension-wise average operation. We measure the similarity of two code diffs by cosine similarity of their semantic vectors and retrieve the most similar code diff paired with the commit message from the parallel training corpus. For each"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.085,
+                0.49,
+                0.149
+            ],
+            "angle": 0,
+            "content": "code diff, we return the first-ranked similar result. But, for the code diff in the training dataset, we return the second-ranked similar result because the first-ranked result is itself."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.114,
+                0.163,
+                0.314,
+                0.177
+            ],
+            "angle": 0,
+            "content": "3.2 Generation module"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.184,
+                0.49,
+                0.295
+            ],
+            "angle": 0,
+            "content": "As shown at the bottom of Figure 1, in the generation module, we treat the retrieved commit message as an exemplar and leverage it to guide the neural network model to generate an accurate commit message. Our generation module consists of three components: three encoders, an exemplar guider, and a decoder."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.298,
+                0.49,
+                0.442
+            ],
+            "angle": 0,
+            "content": "First, following Equation 1, 2, three Transformer-based encoders are adopted to obtain the representations of the input code diff \\((\\mathbf{Enc}^{\\mathbf{d}} = \\mathbf{enc}_1^d,\\mathbf{enc}_2^d,\\dots,\\mathbf{enc}_l^d)\\), the similar code diff \\((\\mathbf{Enc}^{\\mathbf{s}} = \\mathbf{enc}_1^s,\\mathbf{enc}_2^s,\\dots,\\mathbf{enc}_m^s)\\), and similar commit message \\((\\mathbf{Enc}^{\\mathbf{m}} = \\mathbf{enc}_1^m,\\mathbf{enc}_2^m,\\dots,\\mathbf{enc}_n^m)\\) (step ① in Figure 1), where subscripts \\(l,m,n\\) are the length of the input code diff, the similar code diff, and the similar commit message, respectively."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.444,
+                0.49,
+                0.653
+            ],
+            "angle": 0,
+            "content": "Second, since the retrieved similar commit messages may not always accurately describe the content/ intent of the input code diffs even express totally wrong or irrelevant semantics. Therefore, we propose an exemplar guider which first learns the semantic similarity between the retrieved and input code diff and then leverages the information of the similar commit messages based on the learned similarity to guide the commit message generation (step ②). Mathematically, exemplar guider calculate the semantic similarity \\((\\lambda)\\) between the input code diff and the similar code diff based on their representation \\(\\mathbf{Enc}_l^d\\) and \\(\\mathbf{Enc}_m^s\\) (step ② and ③):"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.165,
+                0.667,
+                0.488,
+                0.683
+            ],
+            "angle": 0,
+            "content": "\\[\n\\lambda = \\sigma \\left(\\mathbf {W} _ {\\mathbf {s}} \\left[ m e a n \\left(\\mathbf {E} \\mathbf {n c} ^ {d}\\right), m e a n \\left(\\mathbf {E} \\mathbf {n c} ^ {s}\\right) \\right]\\right) \\tag {4}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.697,
+                0.489,
+                0.745
+            ],
+            "angle": 0,
+            "content": "where \\(\\sigma\\) is the sigmoid activation function, \\(\\mathbf{W}_{\\mathrm{s}}\\) is a learnable matrix, and mean is a dimension-wise average operation."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.747,
+                0.49,
+                0.811
+            ],
+            "angle": 0,
+            "content": "Third, we weight representations of code diff and similar commit message by \\(1 - \\lambda\\) and \\(\\lambda\\), respectively and then concatenate them to obtain the final input encoding."
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.172,
+                0.823,
+                0.488,
+                0.841
+            ],
+            "angle": 0,
+            "content": "\\[\n\\mathbf {E n c} ^ {\\mathrm {d m}} = \\left[ (1 - \\lambda) * \\mathbf {E n c} ^ {\\mathrm {d}}: \\lambda * \\mathbf {E n c} ^ {\\mathrm {s}} \\right] \\tag {5}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.855,
+                0.49,
+                0.919
+            ],
+            "angle": 0,
+            "content": "Finally, we use a Transformer-based decoder to generate the commit message. The decoder consists of multiply decoder layer and each layers includes a masked multi-head self-attention, a"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.549,
+                0.082,
+                0.842,
+                0.172
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Language</td><td>Training</td><td>Validation</td><td>Test</td></tr><tr><td>Java</td><td>160,018</td><td>19,825</td><td>20,159</td></tr><tr><td>C#</td><td>149,907</td><td>18,688</td><td>18,702</td></tr><tr><td>C++</td><td>160,948</td><td>20,000</td><td>20,141</td></tr><tr><td>Python</td><td>206,777</td><td>25,912</td><td>25,837</td></tr><tr><td>JavaScript</td><td>197,529</td><td>24,899</td><td>24,773</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.548,
+                0.181,
+                0.843,
+                0.194
+            ],
+            "angle": 0,
+            "content": "Table 1: Statistics of the evaluation dataset."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.22,
+                0.885,
+                0.412
+            ],
+            "angle": 0,
+            "content": "multi-head cross-attention module, a FFN module and an add & norm module. Different from multi-head self-attention module in the encoder, in terms of one token, masked multi-head self-attention in the decoder can only attend to the previous tokens rather than the before and after context. In \\( b \\)-th cross-attention layer, the input encoding \\( (\\mathbf{Enc}^{\\mathrm{dm}} = (\\mathbf{enc}_1^{\\mathrm{dm}}, \\mathbf{enc}_2^{\\mathrm{dm}}, \\dots, \\mathbf{enc}_{\\mathrm{l + m}}^{\\mathrm{dm}})) \\) is queried by the output of the preceding commit message representations \\( \\mathbf{Msg} = (\\mathbf{msg}_1, \\dots, \\mathbf{msg}_t) \\) obtained by masked multi-head self-attention module."
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.553,
+                0.42,
+                0.882,
+                0.459
+            ],
+            "angle": 0,
+            "content": "\\[\nD e c _ {\\text {h e a d} _ {i} ^ {b}} = \\sum_ {j = 1} ^ {l + m} \\alpha_ {i j} \\left(\\mathbf {W} _ {\\mathbf {V}} ^ {\\mathbf {D e c}} \\mathbf {e n c} _ {\\mathbf {j}} ^ {\\mathbf {b}}\\right) \\tag {6}\n\\]"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.571,
+                0.458,
+                0.837,
+                0.489
+            ],
+            "angle": 0,
+            "content": "\\[\nD e c _ {e _ {i j}} = \\frac {\\left(\\mathbf {W} _ {\\mathbf {Q}} ^ {\\mathbf {D e c}} \\mathbf {m s g} _ {\\mathbf {j}} ^ {\\mathbf {b}}\\right) ^ {T} \\left(\\mathbf {W} _ {\\mathbf {K}} ^ {\\mathbf {D e c}} \\mathbf {e n c} _ {\\mathbf {i}} ^ {\\mathbf {b}}\\right)}{\\sqrt {d _ {k}}}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.499,
+                0.884,
+                0.572
+            ],
+            "angle": 0,
+            "content": "where \\(\\alpha_{ij} = \\frac{\\exp\\text{Dec}_{ij}}{\\sum_{k=1}^{n}\\exp\\text{Dec}_{ik}}\\), \\(\\mathbf{W}_{\\mathbf{Q}}^{\\mathbf{Dec}}\\), \\(\\mathbf{W}_{\\mathbf{K}}^{\\mathbf{Dec}}\\) and \\(\\mathbf{W}_{\\mathbf{V}}^{\\mathbf{Dec}}\\) are trainable projection matrices for queries, keys and values of the decoder layer. t is the length of preceding commit message."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.573,
+                0.884,
+                0.685
+            ],
+            "angle": 0,
+            "content": "Next, we use Equation 2 to obtain the hidden states of each decoder layer. In the last decoder layers, we employ a MLP and softmax operator to obtain the generation probability of each commit message token on the vocabulary. Then we use the cross-entropy as the loss function and apply AdamW for optimization."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.697,
+                0.719,
+                0.714
+            ],
+            "angle": 0,
+            "content": "4 Experimental Setup"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.722,
+                0.617,
+                0.736
+            ],
+            "angle": 0,
+            "content": "4.1 Dataset"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.507,
+                0.743,
+                0.885,
+                0.92
+            ],
+            "angle": 0,
+            "content": "In our experiment, we use a large-scale dataset MCMD (Tao et al., 2021) with five programming languages (PLs): Java, C#, C++, Python and JavaScript. For each PL, MCMD collects commits from the top-100 starred repositories on GitHub and then filters the redundant messages (such as rollback commits) and noisy messages defined in Liu et al. (2018). Finally, to balance the size of data, they randomly sample and retain 450,000 commits for each PL. Each commit contains the code diff, the commit message, the name of the repository,"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.085,
+                0.49,
+                0.15
+            ],
+            "angle": 0,
+            "content": "and the timestamp of commit, etc. To reduce the noise data in the dataset, we further filter out commits that contain multiple files or files that cannot be parsed (such as .jar, .ddl, .mp3, and .apk)."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.114,
+                0.16,
+                0.321,
+                0.175
+            ],
+            "angle": 0,
+            "content": "4.2 Data pre-processing"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.18,
+                0.49,
+                0.486
+            ],
+            "angle": 0,
+            "content": "The code diff in MCMD are based on line-level code change. To obtain more fine-grained code change, following previous study (Panthaplackel et al., 2020), we use a sequence of span of token-level change actions to represent the code diff. Each action is structured as <action> span of tokens <action end>. There are four <action> types, namely, <keep>, <insert>, <delete>, and <replace>. <keep> means that the span of tokens are unchanged. <insert> means that adding span of tokens. <delete> means that deleting span of tokens. <replace> means that the span of tokens in the old version that will be replaced with different span of tokens in the new version. Thus, we extend <replace> to <replace old> and <replace new> to indicate the span of old and new tokens, respectively. We use difflib<sup>1</sup> to extract the sequence of code change actions."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.114,
+                0.497,
+                0.303,
+                0.512
+            ],
+            "angle": 0,
+            "content": "4.3 Hyperparameters"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.517,
+                0.49,
+                0.822
+            ],
+            "angle": 0,
+            "content": "We follow (Tao et al., 2021) to set the maximum lengths of code diff and commit message to 200 and 50, respectively. We use the weight of the encoder of CodeT5-base (Wang et al., 2021b) to initialize the code diff encoders and use the decoder of CodeT5-base to initialize the decoder in Figure 1. The original vocabulary sizes of CodeT5 is 32,100. We add nine special tokens (<keep>, <keep_end>, <insert>, <insert_end>, <delete>, <delete_end>, <replace_old>, <replace_new>, and <replace_end>) and the vocabulary sizes of code and queries become 32109. For the optimizer, we use AdamW with the learning rate 2e-5. The batch size is 32. The max epoch is 20. In addition, we run the experiments 3 times with random seeds 0,1,2 and display the mean value in the paper. The experiments are conducted on a server with 4 GPUs of NVIDIA Tesla V100 and it takes about 1.2 hours each epoch."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.114,
+                0.833,
+                0.312,
+                0.848
+            ],
+            "angle": 0,
+            "content": "4.4 Evaluation metrics"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.854,
+                0.49,
+                0.886
+            ],
+            "angle": 0,
+            "content": "We evaluate the quality of the generated messages using four metrics: BLEU (Papineni et al.,"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.085,
+                0.885,
+                0.246
+            ],
+            "angle": 0,
+            "content": "2002), Meteor (Banerjee and Lavie, 2005), Rouge-L (Lin, 2004), and Cider (Vedantam et al., 2015). These metrics are prevalent metrics in machine translation, text summarization, and image captioning. There are many variants of BLEU being used to measure the generated message, We choose B-Norm (the BLEU result in this paper is B-Norm), which correlates with human perception the most (Tao et al., 2021). The detailed metrics calculation can be found in Appendix."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.258,
+                0.63,
+                0.272
+            ],
+            "angle": 0,
+            "content": "4.5 Baselines"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.279,
+                0.885,
+                0.812
+            ],
+            "angle": 0,
+            "content": "We compare RACE with four end-to-end neural-based models, two IR-based methods, two hybrid approaches which combine IR-based techniques and end-to-end neural-based methods, and three pre-trained-based models. Four end-to-end neural-based models include CommitGen (Jiang et al., 2017), CoDiSum (Xu et al., 2019), NMTGen (Loyola et al., 2017), PtrGNCMsg (Liu et al., 2019) and ATOM (Liu et al., 2020). They all train models from scratch. Two IR-based methods are NNGen (Liu et al., 2018) and Lucene (Apache, 2011), they retrieve the similar code diff based on different similarity measurements and reuse the commit message of the similar code diff as the final result. CoRec and ATOM are all hybrid models which combine the neural-based models and IR-based techniques. Three pre-trained models are CommitBERT, CodeT5-small, and CodeT5-base. They are pre-trained on the large parallel code and natural language corpus and fine-tuned on the commit message generation dataset. All baselines except Lucene, CodeT5-small and CodeT5-base are introduced in Section 2. Lucene is a traditional IR baseline, which uses TF-IDF to represent a code diff as a vector and searches the similar code diff based on the cosine similarity between two vectors. CodeT5-small and CodeT5-base are source code pre-trained models and have achieved promising results in many code-related tasks (Wang et al., 2021b). We fine-tune them on MCMD as strong baselines. In addition, we only evaluate ATOM on Java dataset as the current implementation of ATOM only supports Java."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.823,
+                0.733,
+                0.84
+            ],
+            "angle": 0,
+            "content": "5 Experimental Results"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.849,
+                0.88,
+                0.882
+            ],
+            "angle": 0,
+            "content": "5.1 How does RACE perform compared with baseline approaches?"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.888,
+                0.885,
+                0.92
+            ],
+            "angle": 0,
+            "content": "To evaluate the effectiveness of RACE, we conduct the experiment by comparing it with the 11"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.114,
+                0.892,
+                0.463,
+                0.918
+            ],
+            "angle": 0,
+            "content": "1https://docs.python.org/3/library/difflib. html"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.115,
+                0.082,
+                0.913,
+                0.293
+            ],
+            "angle": 0,
+            "content": "<table><tr><td rowspan=\"2\" colspan=\"2\">Model</td><td colspan=\"4\">Java</td><td colspan=\"4\">C#</td><td colspan=\"4\">C++</td><td colspan=\"4\">Python</td><td colspan=\"4\">JavaScript</td></tr><tr><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td></tr><tr><td rowspan=\"2\">IR-based</td><td>NNGen</td><td>19.41</td><td>12.40</td><td>25.15</td><td>1.23</td><td>22.15</td><td>14.77</td><td>26.46</td><td>1.55</td><td>13.61</td><td>9.39</td><td>18.21</td><td>0.73</td><td>16.06</td><td>10.91</td><td>21.69</td><td>0.92</td><td>18.65</td><td>12.50</td><td>24.45</td><td>1.21</td></tr><tr><td>Lucene</td><td>15.61</td><td>10.56</td><td>19.43</td><td>0.94</td><td>20.68</td><td>13.34</td><td>23.02</td><td>1.36</td><td>13.43</td><td>8.81</td><td>16.78</td><td>0.67</td><td>15.16</td><td>9.63</td><td>18.85</td><td>0.85</td><td>17.66</td><td>11.25</td><td>21.75</td><td>1.02</td></tr><tr><td rowspan=\"4\">End-to-end</td><td>CommitGen</td><td>14.07</td><td>7.52</td><td>18.78</td><td>0.66</td><td>13.38</td><td>8.31</td><td>17.44</td><td>0.63</td><td>11.52</td><td>6.98</td><td>16.75</td><td>0.45</td><td>11.02</td><td>6.43</td><td>16.64</td><td>0.42</td><td>18.67</td><td>11.88</td><td>24.10</td><td>1.08</td></tr><tr><td>CoDiSum</td><td>13.97</td><td>6.02</td><td>16.12</td><td>0.39</td><td>12.71</td><td>5.56</td><td>14.40</td><td>0.36</td><td>12.44</td><td>6.00</td><td>14.39</td><td>0.42</td><td>14.61</td><td>8.59</td><td>17.02</td><td>0.42</td><td>11.22</td><td>5.32</td><td>13.26</td><td>0.28</td></tr><tr><td>NMTGen</td><td>15.52</td><td>8.91</td><td>21.13</td><td>0.86</td><td>12.71</td><td>8.11</td><td>17.16</td><td>0.62</td><td>11.57</td><td>7.06</td><td>17.46</td><td>0.51</td><td>11.41</td><td>7.18</td><td>18.43</td><td>0.48</td><td>18.22</td><td>12.07</td><td>24.43</td><td>1.12</td></tr><tr><td>PtrGNCMsg</td><td>17.71</td><td>11.33</td><td>24.32</td><td>0.99</td><td>15.98</td><td>10.18</td><td>21.16</td><td>0.83</td><td>14.06</td><td>9.63</td><td>20.17</td><td>0.63</td><td>15.89</td><td>11.36</td><td>23.49</td><td>0.76</td><td>20.78</td><td>14.52</td><td>27.87</td><td>1.29</td></tr><tr><td rowspan=\"2\">Hybrid</td><td>ATOM</td><td>16.42</td><td>11.66</td><td>22.67</td><td>0.91</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td></tr><tr><td>CoRec</td><td>18.51</td><td>11.26</td><td>24.78</td><td>1.13</td><td>18.41</td><td>11.70</td><td>23.73</td><td>1.12</td><td>14.02</td><td>8.63</td><td>20.10</td><td>0.72</td><td>15.09</td><td>9.60</td><td>22.35</td><td>0.80</td><td>21.30</td><td>13.84</td><td>27.53</td><td>1.40</td></tr><tr><td rowspan=\"3\">Pre-trained</td><td>CommitBERT</td><td>22.32</td><td>12.63</td><td>28.03</td><td>1.42</td><td>20.67</td><td>12.31</td><td>25.76</td><td>1.25</td><td>16.16</td><td>10.05</td><td>19.90</td><td>0.94</td><td>17.29</td><td>11.31</td><td>22.36</td><td>1.01</td><td>23.40</td><td>15.64</td><td>30.51</td><td>1.54</td></tr><tr><td>CodeT5-small</td><td>22.28</td><td>14.16</td><td>29.71</td><td>1.37</td><td>18.92</td><td>11.71</td><td>24.95</td><td>1.05</td><td>16.08</td><td>11.19</td><td>21.60</td><td>0.79</td><td>17.49</td><td>12.46</td><td>24.65</td><td>0.90</td><td>21.97</td><td>14.48</td><td>28.65</td><td>1.42</td></tr><tr><td>CodeT5-base</td><td>22.76</td><td>14.57</td><td>30.23</td><td>1.43</td><td>22.21</td><td>14.51</td><td>29.08</td><td>1.33</td><td>16.73</td><td>11.69</td><td>22.86</td><td>0.85</td><td>17.99</td><td>12.74</td><td>25.27</td><td>0.96</td><td>22.87</td><td>15.12</td><td>29.81</td><td>1.50</td></tr><tr><td rowspan=\"2\">Ours</td><td rowspan=\"2\">RACE</td><td>25.66</td><td>15.46</td><td>32.02</td><td>1.76</td><td>26.33</td><td>16.37</td><td>31.31</td><td>1.84</td><td>19.13</td><td>12.55</td><td>24.52</td><td>1.14</td><td>21.79</td><td>14.68</td><td>28.35</td><td>1.40</td><td>25.55</td><td>16.31</td><td>31.79</td><td>1.84</td></tr><tr><td>↑13%</td><td>↑6%</td><td>↑6%</td><td>↑23%</td><td>↑19%</td><td>↑13%</td><td>↑8%</td><td>↑38%</td><td>↑14%</td><td>↑7%</td><td>↑7%</td><td>↑34%</td><td>↑21%</td><td>↑15%</td><td>↑12%</td><td>↑46%</td><td>↑12%</td><td>↑8%</td><td>↑7%</td><td>↑23%</td></tr><tr><td>Ablation</td><td>RACE -Guider</td><td>23.37</td><td>13.98</td><td>30.01</td><td>1.53</td><td>21.33</td><td>13.56</td><td>27.33</td><td>1.31</td><td>17.43</td><td>12.10</td><td>22.03</td><td>0.95</td><td>19.44</td><td>13.89</td><td>26.4</td><td>1.01</td><td>23.39</td><td>15.64</td><td>30.51</td><td>1.54</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.113,
+                0.302,
+                0.884,
+                0.345
+            ],
+            "angle": 0,
+            "content": "Table 2: Comparison of RACE with baselines under four metrics on five programming languages. Met., Rou., and Cide. are short for Meteor, Rouge-L, and Cider, respectively. All results are statistically significant (with \\( p < 0.01 \\))."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.37,
+                0.489,
+                0.449
+            ],
+            "angle": 0,
+            "content": "basielines including two IR-based approaches, four end-to-end neural-based approaches, two hybrid approaches, and three pre-train-based approaches in terms of four evaluation metrics. The experimental results are shown in Table 2."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.117,
+                0.452,
+                0.489,
+                0.852
+            ],
+            "angle": 0,
+            "content": "We can see that IR-based models NNGen and Lucene generally outperform end-to-end neural models on average in terms of four metrics. It indicates that retrieved similar results can provide important information for commit message generation. CoRec, which combines the IR-based method and neural method, performs better than NNGen on \\(\\mathrm{C + + }\\) and JavaScript dataset but lower than NNGen on Java, C# and Python. This is because CoRec only leverages the information similar code diff at the inference stage. ATOM, which priorities the generated result of the neural-based model and retrieved result of the IR-based method, also outperforms the IR-based approach Lucene and three neural-based models CommitGen, CoDiSum, and NMTGen. Three pre-trained-based approaches outperform other baselines in terms of four metrics on average. CodeT5-base performs best among them on average. Our approach performs the best among all approaches on 5 programming languages in terms of four metrics. This is because RACE treats the retrieved similar commit message as an exemplar and leverages it to guide the neural network model to generate an accurate commit message."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.855,
+                0.49,
+                0.921
+            ],
+            "angle": 0,
+            "content": "We also give an example of commit messages generated by our approach and the baselines in Figure 2. IR-based methods NNGen and Lucene can retrieve semantically similar but not completely"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.37,
+                0.886,
+                0.563
+            ],
+            "angle": 0,
+            "content": "correct commit message. Specifically, retrieved commit messages contain not only the important semantic (\"Filter out unavailable databases\") of the current code diff but also the extra information (\"Revert\"). Neural network models generally capture the action of \"add\" but fail to further understand the intend of the code diff. The hybrid model CoRec cannot generate the correct commit message either. Our model treats the retrieved result (Revert \"Filter out unavailable databases\") as an exemplar, and guides the neural network model to generate the correct commit message."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.575,
+                0.848,
+                0.607
+            ],
+            "angle": 0,
+            "content": "5.2 What is the effectiveness of exemplar guider?"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.507,
+                0.612,
+                0.886,
+                0.79
+            ],
+            "angle": 0,
+            "content": "We conduct the ablation study to verify the effectiveness of exemplar guider module. Specifically, as shown at the bottom of Figure 1, we directly concatenated the representations of retrieved results and fed them to the decoder to generate commit messages without using the exemplar guider. As shown at the bottom of the Table 2, we can see that the performance of the ablated model (RACE-Guide) degrades in all programming languages in terms of four metrics. It demonstrates the effectiveness of our exemplar guider."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.802,
+                0.825,
+                0.833
+            ],
+            "angle": 0,
+            "content": "5.3 What is the performance when we retrieve \\( k \\) relevant commits?"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.84,
+                0.885,
+                0.92
+            ],
+            "angle": 0,
+            "content": "We also conduct experiments to recall \\( k \\) (\\( k = 1, 3, 5, 7, 9 \\)) most relevant commits to augment the generation model. Specifically, as shown in Figure 1 the relevance of the code diff is measured by the cosine similarity their semantic vectors obtained by"
+        }
+    ],
+    [
+        {
+            "type": "image",
+            "bbox": [
+                0.129,
+                0.086,
+                0.451,
+                0.212
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.133,
+                0.215,
+                0.404,
+                0.226
+            ],
+            "angle": 0,
+            "content": "Reference Filter out unavailable databases"
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.128,
+                0.23,
+                0.493,
+                0.377
+            ],
+            "angle": 0,
+            "content": "<table><tr><td colspan=\"2\">Baselines</td></tr><tr><td>NNGen</td><td>Revert “ Filter out unavailable databases”</td></tr><tr><td>Lucene</td><td>Revert “ filter out unavailable databases ”</td></tr><tr><td>CommitGen</td><td>Merge pull request from mistecrunch / UNK</td></tr><tr><td>NMTGen</td><td>Add &lt;unk&gt; to &lt;unk&gt;</td></tr><tr><td>PtrGNCMsg</td><td>Add support for dashboards in database</td></tr><tr><td>CoRec</td><td>Remove &lt;unk&gt;</td></tr><tr><td>CommitBERT</td><td>Add DatabaseFilter ( )</td></tr><tr><td>CodeT5-small</td><td>[database] Add databasefilter to filter all users</td></tr><tr><td>CodeT5-base</td><td>[hotfix] Adding databasefilter to core.py</td></tr><tr><td>RACE</td><td>Stage I : Revert “ Filter out unavailable databases ”Stage II : Filter out unavailable databases</td></tr></table>"
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.113,
+                0.388,
+                0.49,
+                0.459
+            ],
+            "angle": 0,
+            "content": "Figure 2: An example of generated commit messages. Reference is the developer-written commit message. The results of our approach in stage I and II are returned by the retrieved module and generation module, respectively."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.486,
+                0.49,
+                0.695
+            ],
+            "angle": 0,
+            "content": "Equation 3. Then retrieved \\( k \\) relevant commits are encoded and fed to the exemplar guider to obtain semantic similarities by Equation 4, respectively. Finally, we weight representations of code diff and similar commit messages according to the semantic similarities and feed them to the decoder to generate commit messages step by step. The experimental results are shown in Figure 3. We can see that the performance is generally stable on different \\( k \\). In our future work, we will continue to study alternatives on leveraging the information of the retrieved results, e.g., how many commits to retrieve and how to model the corresponding information."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.114,
+                0.706,
+                0.415,
+                0.738
+            ],
+            "angle": 0,
+            "content": "5.4 Can our framework boost the performance of existing models?"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.743,
+                0.49,
+                0.919
+            ],
+            "angle": 0,
+            "content": "We further study whether our framework can enhance the performance of the existing Seq2Seq neural network model in commit message generation. Therefore, we adapt our framework to four Seq2Seq-based models, namely NMTGen (M1), CommitBERT (M2), CodeT5-small (M3) and CodeT5-base (M4). Specifically, we use the encoder of these models as our code diff encoder and obtain the high-dimensional semantic vectors in the retrieval module (Figure 1). In the generation module, we use the encoder of their models"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.516,
+                0.086,
+                0.885,
+                0.224
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.509,
+                0.238,
+                0.882,
+                0.266
+            ],
+            "angle": 0,
+            "content": "Figure 3: Performance of models augmented with \\( k \\) retrieved relevant commits."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.515,
+                0.285,
+                0.88,
+                0.457
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.508,
+                0.467,
+                0.884,
+                0.525
+            ],
+            "angle": 0,
+            "content": "Figure 4: Performance gains on four models. The original performance of the models are in yellow and gains from our framework are in green. The percentage value in each bar is the rate of improvement."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.553,
+                0.883,
+                0.602
+            ],
+            "angle": 0,
+            "content": "to encode input code diffs, similar code diffs, and similar commit messages. We also use the decoder of their models to generate commit messages."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.604,
+                0.885,
+                0.877
+            ],
+            "angle": 0,
+            "content": "The experimental results are shown in Figure 4, we present the performance of four original models (yellow) and gains (green) from our framework on five programming languages in terms of \\(\\mathrm{BLEU}^2\\) score. Overall, we can see that our framework can improve the performance of all four neural models in all programming languages. Our framework can improve the performance of the original model from \\(7\\%\\) to \\(73\\%\\). Especially, after applying our framework, the performance of NMTGen has more than \\(20\\%\\) improvement on all programming languages. In addition, Our framework can boost the performance of NMTGen on BLUE, Meteor, Rouge-L, and Cider by \\(43\\%\\), \\(49\\%\\), \\(33\\%\\), and \\(61\\%\\) on average, boost CommitBERT by \\(11\\%\\), \\(9\\%\\), \\(11\\%\\), and \\(12\\%\\), boost CodeT5-small by \\(15\\%\\), \\(14\\%\\), \\(11\\%\\), and \\(26\\%\\), and boost CodeT5-base by \\(16\\%\\), \\(10\\%\\),"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.509,
+                0.893,
+                0.883,
+                0.919
+            ],
+            "angle": 0,
+            "content": "2We show results of other three metrics in Appendix due to space limitation. Our conclusions also hold."
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.115,
+                0.082,
+                0.491,
+                0.178
+            ],
+            "angle": 0,
+            "content": "<table><tr><td>Model</td><td>Informativeness</td><td>Conciseness</td><td>Expressiveness</td></tr><tr><td>CommitBERT</td><td>1.22 (±1.02)</td><td>2.03 (±1.04)</td><td>2.46 (±0.99)</td></tr><tr><td>NNGen</td><td>1.03 (±1.00)</td><td>1.74 (±1.01)</td><td>2.36 (±0.95)</td></tr><tr><td>NMTGen</td><td>0.74 (±0.92)</td><td>1.56 (±0.93)</td><td>2.11 (±0.94)</td></tr><tr><td>CoRec</td><td>1.05 (±1.09)</td><td>1.80 (±1.05)</td><td>2.43 (±0.88)</td></tr><tr><td>RACE</td><td>2.49 (±1.10)</td><td>3.08 (±0.96)</td><td>2.85 (±0.84)</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.114,
+                0.187,
+                0.49,
+                0.217
+            ],
+            "angle": 0,
+            "content": "Table 3: Results of human evaluation (standard deviation in parentheses)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.114,
+                0.242,
+                0.235,
+                0.259
+            ],
+            "angle": 0,
+            "content": "\\(8\\%\\), and \\(32\\%\\)"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.114,
+                0.274,
+                0.307,
+                0.289
+            ],
+            "angle": 0,
+            "content": "5.5 Human evaluation"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.296,
+                0.49,
+                0.681
+            ],
+            "angle": 0,
+            "content": "We also conduct a human evaluation by following the previous works (Moreno et al., 2013; Panichella et al., 2016; Shi et al., 2021b) to evaluate the semantic similarity of the commit message generated by RACE and four baselines NNGen, NMTGen, CommitBERT, and CoRec. The four baselines are IR-based, end-to-end neural network-based, hybrid, and pre-trained-based approaches, respectively. We randomly choose 50 code diff from the testing sets and their commit message generated by four approaches. Finally, we sample \\(250 < \\text{code diff}\\), commit message> pairs to score. Specifically, we invite 4 volunteers with excellent English ability and more than three years of software development experience. Each volunteer is asked to assign scores from 0 to 4 (the higher the better) to the generated commit message from the three aspects: Informativeness (the amount of important information about the code diff reflected in the commit message), Conciseness (the extend of extraneous information included in the commit message), and Expressiveness (grammaticality and fluency). Each pair is evaluated by four volunteers, and the final score is the average of them."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.684,
+                0.49,
+                0.892
+            ],
+            "angle": 0,
+            "content": "To verify the agreement among the volunteers, we calculate the Krippendorff's alpha (Hayes and Krippendorff, 2007) and Kendall rank correlation coefficient (Kendall's Tau) values (Kendall, 1945). The value of Krippendorff's alpha is 0.90 and the values of pairwise Kendall's Tau range from 0.73 to 0.95, which indicates that there is a high degree of agreement between the 4 volunteers and that scores are reliable. Table 3 shows the result of human evaluation. RACE is better than other approaches in Informative, Conciseness, and Expressiveness, which means that our approach tends to generate concise and readable commit messages with more"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.085,
+                0.885,
+                0.198
+            ],
+            "angle": 0,
+            "content": "comprehensive semantics. In addition, we confirm the superiority of our approach using Wilcoxon signed-rank tests (Wilcoxon et al., 1970) for the human evaluation. Results show that the improvement of RACE over other approaches is statistically significant with all p-values smaller than 0.05 at \\(95\\%\\) confidence level."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.509,
+                0.211,
+                0.642,
+                0.227
+            ],
+            "angle": 0,
+            "content": "6 Conclusion"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.239,
+                0.885,
+                0.431
+            ],
+            "angle": 0,
+            "content": "This paper proposes a new retrieval-augmented neural commit message generation method, which treats the retrieved similar commit message as an exemplar and uses it to guide the neural network model to generate an accurate and readable commit message. Extensive experimental results demonstrate that our approach outperforms recent baselines and our framework can significantly boost the performance of four neural network models. Our data, source code and Appendix are available at https://github.com/DeepSoftwareAnalytics/RACE."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.51,
+                0.446,
+                0.616,
+                0.461
+            ],
+            "angle": 0,
+            "content": "Limitations"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.473,
+                0.882,
+                0.489
+            ],
+            "angle": 0,
+            "content": "We have identified the following main limitations:"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.49,
+                0.884,
+                0.634
+            ],
+            "angle": 0,
+            "content": "Programming Languages. We only conduct experiments on five programming languages. Although in principle, our framework is not specifically designed for certain languages, models perform differently in different programming languages. Therefore, more experiments are needed to confirm the generality of our framework. In the future, we will extend our study to other programming languages."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.635,
+                0.882,
+                0.716
+            ],
+            "angle": 0,
+            "content": "Code base. Compared with purely neural network-based models, our method needs a code base to retrieve the most similar example from that. This limitation is inherited from IR-based techniques."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.716,
+                0.882,
+                0.796
+            ],
+            "angle": 0,
+            "content": "Training Time. In addition to modeling the information of input code diffs, our model needs to retrieve similar diffs and encode them. Thus, our model takes a long time to train (about 35 hours to train the model)."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.508,
+                0.798,
+                0.882,
+                0.893
+            ],
+            "angle": 0,
+            "content": "Long Code Diffs. Longer code diffs may contain more complex semantics or behaviors. Long diffs (over 512 tokens) are truncated in our approach and some information would be lost. In our future work, we will design mechanisms to better handle long diffs."
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.136,
+                0.904,
+                0.409,
+                0.919
+            ],
+            "angle": 0,
+            "content": "3The result can be found in 1-4 of Appendix"
+        },
+        {
+            "type": "page_footnote",
+            "bbox": [
+                0.531,
+                0.904,
+                0.679,
+                0.919
+            ],
+            "angle": 0,
+            "content": "Available in Appendix"
+        }
+    ],
+    [
+        {
+            "type": "title",
+            "bbox": [
+                0.115,
+                0.085,
+                0.279,
+                0.101
+            ],
+            "angle": 0,
+            "content": "Acknowledgement"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.113,
+                0.11,
+                0.49,
+                0.238
+            ],
+            "angle": 0,
+            "content": "We thank reviewers for their valuable comments on this work. This research was supported by National Key R&D Program of China (No. 2017YFA0700800). We would like to thank Jiaqi Guo and Wenchao Gu for their valuable suggestions and feedback during the work discussion process. We also thank the participants of our human evaluation for their time."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.115,
+                0.265,
+                0.214,
+                0.28
+            ],
+            "angle": 0,
+            "content": "References"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.116,
+                0.288,
+                0.327,
+                0.302
+            ],
+            "angle": 0,
+            "content": "Apache. 2011. Apache lucene."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.312,
+                0.49,
+                0.365
+            ],
+            "angle": 0,
+            "content": "Satanjeev Banerjee and Alon Lavie. 2005. METEOR: an automatic metric for MT evaluation with improved correlation with human judgments. In IEEvaluation@ACL."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.375,
+                0.489,
+                0.441
+            ],
+            "angle": 0,
+            "content": "Mike Barnett, Christian Bird, João Brunet, and Shuvendu K. Lahiri. 2015. Helping developers help themselves: Automatic decomposition of code review changesets. In ICSE (1), pages 134-144. IEEE Computer Society."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.451,
+                0.489,
+                0.491
+            ],
+            "angle": 0,
+            "content": "Raymond P. L. Buse and Westley Weimer. 2010. Automatically documenting program changes. In ASE, pages 33-42. ACM."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.5,
+                0.49,
+                0.566
+            ],
+            "angle": 0,
+            "content": "Luis Fernando Cortes-Coy, Mario Linares Vásquez, Jairo Aponte, and Denys Poshyvanyk. 2014. On automatically generating commit messages via summarization of source code changes. In SCAM, pages 275-284. IEEE Computer Society."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.576,
+                0.49,
+                0.63
+            ],
+            "angle": 0,
+            "content": "Martin Dias, Alberto Bacchelli, Georgios Gousios, Damien Cassou, and Stephane Ducasse. 2015. Untangling fine-grained code changes. In SANER, pages 341-350. IEEE Computer Society."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.639,
+                0.49,
+                0.692
+            ],
+            "angle": 0,
+            "content": "Jinhao Dong, Yiling Lou, Qihao Zhu, Zeyu Sun, Zhilin Li, Wenjie Zhang, and Dan Hao. 2022. Fira: Fine-grained graph-based code change representation for automated commit message generation."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.702,
+                0.49,
+                0.792
+            ],
+            "angle": 0,
+            "content": "Lun Du, Xiaozhou Shi, Yanlin Wang, Ensheng Shi, Shi Han, and Dongmei Zhang. 2021. Is a single model enough? mucos: A multi-model ensemble learning approach for semantic code search. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management, pages 2994-2998."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.803,
+                0.49,
+                0.87
+            ],
+            "angle": 0,
+            "content": "Robert Dyer, Hoan Anh Nguyen, Hridesh Rajan, and Tien N. Nguyen. 2013. Boa: a language and infrastructure for analyzing ultra-large-scale software repositories. In ICSE, pages 422-431. IEEE Computer Society."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.879,
+                0.49,
+                0.919
+            ],
+            "angle": 0,
+            "content": "Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.116,
+                0.288,
+                0.49,
+                0.919
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.53,
+                0.086,
+                0.885,
+                0.14
+            ],
+            "angle": 0,
+            "content": "Codebert: A pre-trained model for programming and natural languages. In EMNLP (Findings), volume EMNLP 2020 of Findings of ACL, pages 1536-1547. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.148,
+                0.884,
+                0.175
+            ],
+            "angle": 0,
+            "content": "Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. 2018. Deep code search. In ICSE, pages 933-944. ACM."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.184,
+                0.885,
+                0.237
+            ],
+            "angle": 0,
+            "content": "Andrew F Hayes and Klaus Krippendorff. 2007. Answering the call for a standard reliability measure for coding data. Communication methods and measures, 1(1):77-89."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.246,
+                0.885,
+                0.311
+            ],
+            "angle": 0,
+            "content": "Yuan Huang, Nan Jia, Hao-Jie Zhou, Xiangping Chen, Zibin Zheng, and Mingdong Tang. 2020. Learning human-written commit messages to document code changes. J. Comput. Sci. Technol., 35(6):1258-1277."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.322,
+                0.885,
+                0.387
+            ],
+            "angle": 0,
+            "content": "Yuan Huang, Qiaoyang Zheng, Xiangping Chen, Yingfei Xiong, Zhiyong Liu, and Xiaonan Luo. 2017. Mining version control system for automatically generating commit comment. In ESEM, pages 414-423. IEEE Computer Society."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.396,
+                0.885,
+                0.436
+            ],
+            "angle": 0,
+            "content": "Siyuan Jiang, Ameer Armaly, and Collin McMillan. 2017. Automatically generating commit messages from diffs using neural machine translation. In ASE."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.445,
+                0.885,
+                0.511
+            ],
+            "angle": 0,
+            "content": "Tae Hwan Jung. 2021. Commitbert: Commit message generation using pre-trained programming language model. In Proceedings of the 1st Workshop on Natural Language Processing for Programming (NLP4Prog 2021), pages 26-33."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.52,
+                0.885,
+                0.547
+            ],
+            "angle": 0,
+            "content": "Maurice G Kendall. 1945. The treatment of ties in ranking problems. Biometrika, 33(3):239-251."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.556,
+                0.885,
+                0.634
+            ],
+            "angle": 0,
+            "content": "Patrick S. H. Lewis, Ethan Perez, Aleksandra Pik-tus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Roektaschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive NLP tasks. In NeurIPS."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.644,
+                0.885,
+                0.683
+            ],
+            "angle": 0,
+            "content": "Chin-Yew Lin. 2004. ROUGE: A package for automatic evaluation of summaries. In Text Summarization Branches Out."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.693,
+                0.885,
+                0.746
+            ],
+            "angle": 0,
+            "content": "Qin Liu, Zihe Liu, Hongming Zhu, Hongfei Fan, Bowen Du, and Yu Qian. 2019. Generating commit messages from diffs using pointer-generator network. In MSR, pages 299-309. IEEE / ACM."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.755,
+                0.885,
+                0.808
+            ],
+            "angle": 0,
+            "content": "Shangqing Liu, Cuiyun Gao, Sen Chen, Lun Yiu Nie, and Yang Liu. 2020. ATOM: commit message generation based on abstract syntax tree and hybrid ranking. TSE, PP:1-1."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.817,
+                0.885,
+                0.882
+            ],
+            "angle": 0,
+            "content": "Zhongxin Liu, Xin Xia, Ahmed E. Hassan, David Lo, Zhenchang Xing, and Xinyu Wang. 2018. Neural-machine-translation-based commit message generation: how far are we? In ASE, pages 373-384. ACM."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.892,
+                0.885,
+                0.919
+            ],
+            "angle": 0,
+            "content": "Ilya Loshchilov and Frank Hutter. 2019. Decoupled weight decay regularization. In ICLR."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.512,
+                0.086,
+                0.885,
+                0.919
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ],
+    [
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.086,
+                0.49,
+                0.153
+            ],
+            "angle": 0,
+            "content": "Pablo Loyola, Edison Marrese-Taylor, and Yutaka Matsuo. 2017. A neural architecture for generating natural language descriptions from source code changes. In ACL (2), pages 287-292. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.166,
+                0.488,
+                0.232
+            ],
+            "angle": 0,
+            "content": "Laura Moreno, Jairo Aponte, Giriprasad Sridhara, Andrian Marcus, Lori L. Pollock, and K. Vijay-Shanker. 2013. Automatic generation of natural language summaries for java classes. In ICPC, pages 23-32. IEEE Computer Society."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.245,
+                0.488,
+                0.298
+            ],
+            "angle": 0,
+            "content": "Lun Yiu Nie, Cuiyun Gao, Zhicong Zhong, Wai Lam, Yang Liu, and Zenglin Xu. 2021. Coregen: Contextualized code representation learning for commit message generation. Neurocomputing, 459:97-107."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.311,
+                0.488,
+                0.377
+            ],
+            "angle": 0,
+            "content": "Sebastiano Panichella, Annibale Panichella, Moritz Beller, Andy Zaidman, and Harald C. Gall. 2016. The impact of test case summaries on bug fixing performance: an empirical investigation. In ICSE, pages 547-558. ACM."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.39,
+                0.488,
+                0.456
+            ],
+            "angle": 0,
+            "content": "Sheena Panthaplackel, Pengyu Nie, Milos Gligoric, Junyi Jessy Li, and Raymond J. Mooney. 2020. Learning to update natural language comments based on code changes. In ACL, pages 1853-1868. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.469,
+                0.488,
+                0.509
+            ],
+            "angle": 0,
+            "content": "Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. Bleu: a method for automatic evaluation of machine translation. In ACL."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.522,
+                0.488,
+                0.588
+            ],
+            "angle": 0,
+            "content": "Jinfeng Shen, Xiaobing Sun, Bin Li, Hui Yang, and Jiajun Hu. 2016. On automatic summarization of what and why information in source code changes. In COMPSAC, pages 103-112. IEEE Computer Society."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.602,
+                0.488,
+                0.68
+            ],
+            "angle": 0,
+            "content": "Ensheng Shi, Wenchao Gub, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2022a. Enhancing semantic code search with multimodal contrastive learning and soft data augmentation. arXiv preprint arXiv:2204.03293."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.694,
+                0.488,
+                0.746
+            ],
+            "angle": 0,
+            "content": "Ensheng Shi, Yanlin Wang, Lun Du, Junjie Chen, Shi Han, Hongyu Zhang, Dongmei Zhang, and Hongbin Sun. 2022b. On the evaluation of neural code summarization. In ICSE."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.76,
+                0.488,
+                0.825
+            ],
+            "angle": 0,
+            "content": "Ensheng Shi, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2021a. Cast: Enhancing code summarization with hierarchical splitting and reconstruction of abstract syntax trees. In EMNLP."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.117,
+                0.84,
+                0.488,
+                0.919
+            ],
+            "angle": 0,
+            "content": "Ensheng Shi, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2021b. CAST: enhancing code summarization with hierarchical splitting and reconstruction of abstract syntax trees. In EMNLP (1), pages 4053-4062. Association for Computational Linguistics."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.117,
+                0.086,
+                0.49,
+                0.919
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.513,
+                0.086,
+                0.882,
+                0.151
+            ],
+            "angle": 0,
+            "content": "Wei Tao, Yanlin Wang, Ensheng Shi, Lun Du, Shi Han, Hongyu Zhang, Dongmei Zhang, and Wenqiang Zhang. 2021. On the evaluation of commit message generation models: An experimental study. In ICSME."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.162,
+                0.882,
+                0.215
+            ],
+            "angle": 0,
+            "content": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In NIPS, pages 5998-6008."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.225,
+                0.882,
+                0.264
+            ],
+            "angle": 0,
+            "content": "Ramakrishna Vedantam, C. Lawrence Zitnick, and Devi Parikh. 2015. Cider: Consensus-based image description evaluation. In CVPR."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.274,
+                0.882,
+                0.339
+            ],
+            "angle": 0,
+            "content": "Haoye Wang, Xin Xia, David Lo, Qiang He, Xinyu Wang, and John Grundy. 2021a. Context-aware retrieval-based deep commit message generation. ACM Trans. Softw. Eng. Methodol., 30(4):56:1-56:30."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.35,
+                0.882,
+                0.415
+            ],
+            "angle": 0,
+            "content": "Yanlin Wang, Lun Du, Ensheng Shi, Yuxuan Hu, Shi Han, and Dongmei Zhang. 2020. Cocogum: Contextual code summarization with multi-relational gnn on ums. Technical report, Microsoft, MSR-TR-2020-16. [Online]."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.426,
+                0.882,
+                0.504
+            ],
+            "angle": 0,
+            "content": "Yue Wang, Weishi Wang, Shafiq R. Joty, and Steven C. H. Hoi. 2021b. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. In EMNLP (1), pages 8696-8708. Association for Computational Linguistics."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.514,
+                0.882,
+                0.581
+            ],
+            "angle": 0,
+            "content": "Bolin Wei, Yongmin Li, Ge Li, Xin Xia, and Zhi Jin. 2020. Retrieve and refine: exemplar-based neural comment generation. In 2020 35th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 349-360. IEEE."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.59,
+                0.882,
+                0.655
+            ],
+            "angle": 0,
+            "content": "Frank Wilcoxon, SK Katti, and Roberta A Wilcox. 1970. Critical values and probability levels for the wilcoxon rank sum test and the wilcoxon signed rank test. Selected tables in mathematical statistics, 1:171-259."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.666,
+                0.882,
+                0.72
+            ],
+            "angle": 0,
+            "content": "Shengbin Xu, Yuan Yao, Feng Xu, Tianxiao Gu, Hanghang Tong, and Jian Lu. 2019. Commit message generation for source code changes. In *IJCAI*, pages 3975-3981. ijcai.org."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.728,
+                0.882,
+                0.782
+            ],
+            "angle": 0,
+            "content": "HongChien Yu, Chenyan Xiong, and Jamie Callan. 2021. Improving query representations for dense retrieval with pseudo relevance feedback. In CIKM, pages 3592-3596. ACM."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.512,
+                0.791,
+                0.882,
+                0.831
+            ],
+            "angle": 0,
+            "content": "Jian Zhang, Xu Wang, Hongyu Zhang, Hailong Sun, and Xudong Liu. 2020. Retrieval-based neural source code summarization. In ICSE."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.512,
+                0.086,
+                0.882,
+                0.831
+            ],
+            "angle": 0,
+            "content": null
+        }
+    ]
+]

2203.02xxx/2203.02700/3d69ca7f-39a5-4c99-b9df-bcb921fe9d04_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c8ebd879a8873c60b56b95b8ac0aa4eb3fd0bf94f885520814f4ad38e73a500
+size 653890

2203.02xxx/2203.02700/full.md

@@ -0,0 +1,310 @@
+# RACE: Retrieval-Augmented Commit Message Generation
+
+Ensheng Shi $^{a}$  Yanlin Wang $^{b,\S,\dagger}$  Wei Tao $^{c}$  Lun Du $^{d}$
+
+Hongyu Zhang<sup>e</sup> Shi Hand Dongmei Zhang<sup>d</sup> Hongbin Sun<sup>a,§</sup>
+
+$^{a}$ Xi'an Jiaotong University  $^{b}$ School of Software Engineering, Sun Yat-sen University
+
+$^{c}$ Fudan University  $^{d}$ Microsoft Research  $^{e}$ The University of Newcastle
+
+s1530129650@stu.xjtu.edu.cn, hsun@mail.xjtu.edu.cn
+
+wangylin36@mail.sysu.edu.cn，wtao18@fudan.edu.cn
+
+{lun.du, shihan, dongmeiz}@microsoft.com
+
+hongyu.zhang@newcastle.edu.au
+
+# Abstract
+
+Commit messages are important for software development and maintenance. Many neural network-based approaches have been proposed and shown promising results on automatic commit message generation. However, the generated commit messages could be repetitive or redundant. In this paper, we propose RACE, a new retrieval-augmented neural commit message generation method, which treats the retrieved similar commit as an exemplar and leverages it to generate an accurate commit message. As the retrieved commit message may not always accurately describe the content/intent of the current code diff, we also propose an exemplar guider, which learns the semantic similarity between the retrieved and current code diff and then guides the generation of commit message based on the similarity. We conduct extensive experiments on a large public dataset with five programming languages. Experimental results show that RACE can outperform all baselines. Furthermore, RACE can boost the performance of existing Seq2Seq models in commit message generation. Our data and source code are available at https://github.com/DeepSoftwareAnalytics/RACE.
+
+# 1 Introduction
+
+In software development and maintenance, source code is frequently changed. In practice, code changes are often documented as natural language commit messages, which summarize what (content) the code changes are or why (intent) the code is changed (Buse and Weimer, 2010; Cortes-Coy et al., 2014). High-quality commit messages are essential to help developers understand the evolution of software without diving into implementation details, which can save a large amount of
+
+time and effort in software development and maintenance (Dias et al., 2015; Barnett et al., 2015). However, it is difficult to write high-quality commit messages due to lack of time, clear motivation, or experienced skills. Even for seasoned developers, it still poses a considerable amount of extra workload to write a concise and informative commit message for massive code changes (Nie et al., 2021). It is also reported that around  $14\%$  of commit messages over 23,000 projects in SourceForge are left empty (Dyer et al., 2013). Thus, automatically generating commit messages becomes an important task.
+
+Over the years, many approaches have been proposed to automatically generate commit messages. Early studies (Shen et al., 2016; Cortes-Coy et al., 2014) are mainly based on predefined rules or templates, which may not cover all situations or comprehensively infer the intentions behind code changes. Later, some studies (Liu et al., 2018; Huang et al., 2017, 2020) adopt information retrieval (IR) techniques to reuse commit messages of similar code changes. They can take advantage of similar examples, but the reused commit messages might not correctly describe the content/intent of the current code change. Recently, some Seq2Seq-based neural network models (Loyola et al., 2017; Jiang et al., 2017; Xu et al., 2019; Liu et al., 2019; Jung, 2021) have been proposed to understand code diffs and generate the high-quality commit messages. These approaches show promising performance, but they tend to generate high-frequency and repetitive tokens and the generated commit messages have the problem of insufficient information and poor readability (Wang et al., 2021a; Liu et al., 2018). Some studies (Liu et al., 2020; Wang et al., 2021a) also explore the combination of neural-based and IR-based techniques. Liu et al. (2020) propose an approach to rank the retrieved commit message (obtained by a simple IR-based model) and the generated commit message (ob-
+
+tained by a neural network model). Wang et al. (2021a) propose to use the similar code diff as auxiliary information in the inference stage, while the model is not trained to learn how to effectively utilize the information of retrieval results. Therefore, both of them fail to take advantage of the information of retrieved similar results well.
+
+In this paper, we propose a novel model RACE (Retrieval-Augmented Commit mEssay generation), which retrieves a similar commit message as an exemplar, guides the neural model to learn the content of the code diff and the intent behind the code diff, and generates the readable and informative commit message. The key idea of our approach is retrieval and augmentation. Specifically, we first train a code diff encoder to learn the semantics of code diffs and encode the code diff into high-dimensional semantic space. Then, we retrieve the semantically similar code diff paired with the commit message on a large parallel corpus based on the similarity measured by vectors' distance. Next, we treat the similar commit message as an exemplar and leverage it to guide the neural-based models to generate an accurate commit message. However, the retrieved commit messages may not accurately describe the content/intent of current code diffs and may even contain wrong or irrelevant information. To avoid the retrieved samples dominating the processing of commit message generation, we propose an exemplar guider, which first learns the semantic similarity between the retrieved and current code diff and then leverages the information of the exemplar based on the learned similarity to guide the commit message generation.
+
+To evaluate the effectiveness of RACE, we conduct experiments on a large-scale dataset MCMD (Tao et al., 2021) with five programming language (Java, C#, C++, Python and JavaScript) and compare RACE with 11 state-of-the-art approaches. Experimental results show that: (1) RACE significantly outperforms existing state-of-the-art approaches in terms of four metrics (BLUE, Meteor, Rouge-L and Cider) on the commit message generation. (2) RACE can boost the performance of existing Seq2Seq models in commit message generation. For example, it can improve the performance of NMTGen (Loyola et al., 2017), CommitBERT (Jung, 2021), CodeT5-small (Wang et al., 2021b) and CodeT5-base (Wang et al., 2021b) by  $43\%$ ,  $11\%$ ,  $15\%$ , and  $16\%$  on average in terms of BLEU, respectively. In addition,
+
+we also conduct human evaluation to confirm the effectiveness of RACE.
+
+We summarize the main contributions of this paper as follows:
+
+- We propose a retrieval-augmented neural commit message generation model, which treats the retrieved similar commit as an exemplar and leverages it to guide neural network model to generate informative and readable commit messages.  
+- We apply our retrieval-augmented framework to four existing neural network-based approaches (NMTGen, CommitBERT, CodeT5-small, and CodeT5-base) and greatly boost their performance.  
+- We perform extensive experiments including human evaluation on a large multi-programming-language dataset and the results confirm the effectiveness of our approach over state-of-the-art approaches.
+
+# 2 Related Work
+
+Code intelligence, which leverages machine learning especially deep learning-based method to understand source code, is an emerging topic and has obtained the promising results in many software engineering tasks, such as code summarization (Zhang et al., 2020; Shi et al., 2021a, 2022b; Wang et al., 2020) and code search (Gu et al., 2018; Du et al., 2021; Shi et al., 2022a). Among them, commit message generation plays an important role in the software evolution.
+
+In early work, information retrieval techniques are introduced to commit message generation (Liu et al., 2018; Huang et al., 2017, 2020). For instance, ChangeDoc (Huang et al., 2020) retrieves the most similar commits according to the syntax or semantics in the code diff and reuses commit messages of similar code diffs. NNGen (Liu et al., 2018) is a simple yet effective retrieval-based method using the nearest neighbor algorithm. It firstly recalls the top-k similar code diffs in the parallel corpus based on cosine similarity between bag-of-words vectors of code diffs. Then select the most similar result based on BLEU scores between each of them (topk results) and the input code diff. These approaches can reuse similar examples and the reused commit messages are usually readable and understandable.
+
+Recently, many neural-based approaches (Loyola et al., 2017; Jiang et al., 2017; Xu et al., 2019;
+
+Liu et al., 2019, 2020; Jung, 2021; Dong et al., 2022; Nie et al., 2021; Wang et al., 2021a) have been used to learn the semantic of code diffs and translate them into commit messages. For example, NMTGen (Loyola et al., 2017) and CommitGen (Jiang et al., 2017) treat the code diffs as plain texts and adopt the Seq2Seq neural network with different attention mechanisms to translate them into commit messages. CoDiSum (Xu et al., 2019) extracts both code structure and code semantics from code diffs and jointly models them with a multi-layer bidirectional GRU to better learn the representations of code diffs. PtrGNCMsg (Liu et al., 2019) incorporates the pointer-generator network into the Seq2Seq model to handle out-of-vocabulary (OOV) words. CommitBERT leverage CodeBERT (Feng et al., 2020), a pre-trained language model for source code, to learn the semantic representations of code diffs and adopt a Transformer-based (Vaswani et al., 2017) decoder to generate the commit message. These approaches show promising results on the generation of commit messages.
+
+Recently, introducing retrieved relevant results into the training process has been found useful in most generation tasks (Lewis et al., 2020; Yu et al., 2021; Wei et al., 2020). Some studies (Liu et al., 2020; Wang et al., 2021a) also explore the combination of neural-based models and IR-based techniques to generate commit messages. ATOM (Liu et al., 2020) ensembles the neural-based model and the IR-based technique through the hybrid ranking. Specifically, it uses BiLSTM to encode ASTs paths extracted from ASTs of code diffs and adopt a decoder to generate commit messages. It also uses TF-IDF technique to represent code diffs as vectors and retrieves the most similar commit message based on cosine similarity. The generated and retrieved commit messages are finally prioritized by a hybrid ranking module. CoRec (Wang et al., 2021a) is also a hybrid model and only considers the retrieved result during the inference. Specifically, at the training stage, they use an encoder-decoder neural model to encode the input code diffs by an encoder and generate commit messages by a decoder. At the inference stage, they first use the trained encoder to retrieve the most similar code diff from the training set. Then they reuse a trained encoder-decoder to encode the input and retrieved code diff, combine the probability distributions (obtained by two decoders) of each word, and generate
+
+the final commit message step by step. In summary, ATOM does not learn to refine the retrieved results or the generated results, and CoRec is not trained to utilize the information of retrieval results. Therefore, both of them fail to take full advantage of the retrieved similar results. In this paper, we treat the retrieved similar commit as an exemplar and train the model to leverage the exemplar to enhance commit message generation.
+
+# 3 Proposed Approach
+
+The overview of RACE is shown in Figure 1. It includes two modules: retrieval module and generation module. Specifically, RACE firstly retrieves the most semantically similar code diff paired with the commit message from the large parallel training corpus. The semantic similarity between two code diffs is measured by the cosine similarity of vectors obtained by a code diff encoder. Next, RACE treats the retrieved commit message as an example and uses it to guide the neural network to generate an understandable and concise commit message.
+
+# 3.1 Retrieval module
+
+In this module, we aim to retrieve the most semantically similar result. Specifically, we first train an encoder-decoder neural network on the large commit message generation dataset. The encoder is used to learn the semantics of code diffs and encode code diffs into a high-dimension semantic space. Then we retrieve the most semantically similar code diff paired with the commit message from the large parallel training corpus. The semantic similarity between two code diffs is measured by the cosine similarity of vectors obtained by a well-trained code diff encoder.
+
+Recently, encoder-decoder neural network models (Loyola et al., 2017; Jiang et al., 2017; Jung, 2021), which leverage an encoder to learn the semantic of code diff and employ a decoder to generate the commit message, have shown their superiority in the understanding of code offs and commit messages generation. To enable the code diff encoder to understand the semantics of code offs, we train it with a commit message generator on a large commit message generation dataset, which consists of about 0.9 million <code diff, commit message> pairs.
+
+To capture long-range dependencies (e.g. a variable is initialized before the changed line) and more contextual information of code diffs, we em
+
+![](images/fd4aef83d51ff54aa0f9e77f50d30f3d1820f9418368e54b218e777453a75071.jpg)
+
+![](images/1f23e86417c1a02989374e6f2ce6197fd5f838385a9bb232fd5ef16290277b89.jpg)  
+Figure 1: The architecture of RACE. It includes two modules: retrieval module and generation module. The retrieval module is used to retrieve the most similar code diff and commit message. The generation module leverages the retrieved result to enhance the performance of neural network models.
+
+ploy a Transformer-based encoder to learn the semantic representations of input code diffs. As shown in Figure 1, a Transformer-based encoder is stacked with multiple encoder layers. Each layer consists of four parts, namely, a multi-head self-attention module, a relative position embedding module, a feed forward network (FFN) and an add & norm module. In  $b$ -th attention head, the input  $\mathbf{X}^{\mathrm{b}} = (\mathbf{x}_1^{\mathrm{b}},\mathbf{x}_2^{\mathrm{b}},\dots,\mathbf{x}_1^{\mathrm{b}})$  (where  $\mathbf{X}^{\mathrm{b}} = \mathbf{X}[(b - 1)*head_{dim}:b*head_{dim}]$ ,  $\mathbf{X}$  is the sequence of code diff embedding,  $head_{dim}$  is the dimension of each head and  $l$  is the input sequence length.) is transformed to  $(\mathbf{Head}^{b} = \mathbf{head}_{1}^{\mathrm{b}},\mathbf{head}_{2}^{\mathrm{b}},\dots,\mathbf{head}_{l}^{\mathrm{b}})$  by:
+
+$$
+\mathbf {h e a d} _ {\mathrm {i}} ^ {\mathrm {b}} = \sum_ {j = 1} ^ {l} \alpha_ {i j} \left(\mathbf {W} _ {\mathbf {V}} \mathbf {x} _ {\mathrm {j}} ^ {\mathrm {b}} + \mathbf {p} _ {\mathrm {i j}} ^ {\mathbf {V}}\right) \tag {1}
+$$
+
+$$
+e _ {i j} = \frac {\left(\mathbf {W _ {Q}} \mathbf {x _ {i} ^ {b}}\right) ^ {T} \left(\mathbf {W _ {K}} \mathbf {x _ {j} ^ {b}} + \mathbf {p _ {i j} ^ {K}}\right)}{\sqrt {d _ {k}}}
+$$
+
+where  $\alpha_{ij} = \frac{\exp e_{ij}}{\sum_{k=1}^{n}\exp e_{ik}}$ ,  $\mathbf{W}_{\mathbf{Q}}$ ,  $\mathbf{W}_{\mathbf{K}}$  and  $\mathbf{W}_{\mathbf{V}}$  are learnable matrix for queries, keys and values.  $d_k$  is the dimension of queries and keys;  $\mathbf{p}_{\mathbf{ij}}^{\mathbf{K}}$  and  $\mathbf{p}_{\mathbf{ij}}^{\mathbf{V}}$  are relative positional representations for positions  $i$  and  $j$ .
+
+The outputs of all heads are concatenated and then fed to the FFN modules which is a multi-layer perception. The add & norm operation are employed after the multi-head attention and FFN modules. The calculations are as follows:
+
+$$
+\begin{array}{l} \mathbf {H e a d} = C o n c a t \left(\mathbf {H e a d} ^ {\mathbf {1}}, \mathbf {H e a d} ^ {\mathbf {d}}, \mathbf {H e a d} ^ {\mathbf {B}}\right) \\ \mathbf {H i d} = a d d \& n o r m (\mathbf {H e a d}, \mathbf {X}) \end{array} \tag {2}
+$$
+
+$$
+\mathbf {E n c} = a d d \& n o r m (\mathbf {F F N} (\mathbf {H i d}), \mathbf {H i d})
+$$
+
+where  $add\&norm(\mathbf{A_1},\mathbf{A_2}) = LN(\mathbf{A_1} + \mathbf{A_2})$ $B$  is the number of heads and  $LN$  is layer normalization. The final output of encoder is sent to Transformer-based decoder to generate the commit message step by step. We use cross-entropy as loss function and adopt AdamW (Loshchilov and Hutter, 2019) to optimize the parameters of the code diff encoder and the decoder at the top of Figure 1.
+
+Next, the retrieval module is used to retrieve the most similar result from a large parallel training corpus. We firstly use the above code diff encoder to map code diffs into a high-dimensional latent space and retrieve the most similar example based on cosine similarity.
+
+Specifically, after being trained in the commit message generation dataset, the code diff encoder can capture the semantic of code diff well. We use well-trained code diff encoder following a mean-pooling operation to map the code diff into a high dimensional space. Mathematically, given the input code diff embedding  $\mathbf{X} = (\mathbf{x}_1,\mathbf{x}_2,\dots,\mathbf{x}_l)$ , the code diff encoder can transformed them to  $\mathbf{Enc} = (\mathbf{enc}_1,\mathbf{enc}_2,\dots,\mathbf{enc}_l)$ . Then we obtain the semantic vector of the code diff by pooling operation:
+
+$$
+\operatorname {v e c} = \text {p o o l i n g} (\mathbf {E n c}) = \text {m e a n} \left(\mathbf {e n c} _ {1}, \mathbf {e n c} _ {2}, \dots , \mathbf {e n c} _ {1}\right) \tag {3}
+$$
+
+where mean is a dimension-wise average operation. We measure the similarity of two code diffs by cosine similarity of their semantic vectors and retrieve the most similar code diff paired with the commit message from the parallel training corpus. For each
+
+code diff, we return the first-ranked similar result. But, for the code diff in the training dataset, we return the second-ranked similar result because the first-ranked result is itself.
+
+# 3.2 Generation module
+
+As shown at the bottom of Figure 1, in the generation module, we treat the retrieved commit message as an exemplar and leverage it to guide the neural network model to generate an accurate commit message. Our generation module consists of three components: three encoders, an exemplar guider, and a decoder.
+
+First, following Equation 1, 2, three Transformer-based encoders are adopted to obtain the representations of the input code diff  $(\mathbf{Enc}^{\mathbf{d}} = \mathbf{enc}_1^d,\mathbf{enc}_2^d,\dots,\mathbf{enc}_l^d)$ , the similar code diff  $(\mathbf{Enc}^{\mathbf{s}} = \mathbf{enc}_1^s,\mathbf{enc}_2^s,\dots,\mathbf{enc}_m^s)$ , and similar commit message  $(\mathbf{Enc}^{\mathbf{m}} = \mathbf{enc}_1^m,\mathbf{enc}_2^m,\dots,\mathbf{enc}_n^m)$  (step ① in Figure 1), where subscripts  $l,m,n$  are the length of the input code diff, the similar code diff, and the similar commit message, respectively.
+
+Second, since the retrieved similar commit messages may not always accurately describe the content/ intent of the input code diffs even express totally wrong or irrelevant semantics. Therefore, we propose an exemplar guider which first learns the semantic similarity between the retrieved and input code diff and then leverages the information of the similar commit messages based on the learned similarity to guide the commit message generation (step ②). Mathematically, exemplar guider calculate the semantic similarity  $(\lambda)$  between the input code diff and the similar code diff based on their representation  $\mathbf{Enc}_l^d$  and  $\mathbf{Enc}_m^s$  (step ② and ③):
+
+$$
+\lambda = \sigma \left(\mathbf {W} _ {\mathbf {s}} \left[ m e a n \left(\mathbf {E} \mathbf {n c} ^ {d}\right), m e a n \left(\mathbf {E} \mathbf {n c} ^ {s}\right) \right]\right) \tag {4}
+$$
+
+where  $\sigma$  is the sigmoid activation function,  $\mathbf{W}_{\mathrm{s}}$  is a learnable matrix, and mean is a dimension-wise average operation.
+
+Third, we weight representations of code diff and similar commit message by  $1 - \lambda$  and  $\lambda$ , respectively and then concatenate them to obtain the final input encoding.
+
+$$
+\mathbf {E n c} ^ {\mathrm {d m}} = \left[ (1 - \lambda) * \mathbf {E n c} ^ {\mathrm {d}}: \lambda * \mathbf {E n c} ^ {\mathrm {s}} \right] \tag {5}
+$$
+
+Finally, we use a Transformer-based decoder to generate the commit message. The decoder consists of multiply decoder layer and each layers includes a masked multi-head self-attention, a
+
+<table><tr><td>Language</td><td>Training</td><td>Validation</td><td>Test</td></tr><tr><td>Java</td><td>160,018</td><td>19,825</td><td>20,159</td></tr><tr><td>C#</td><td>149,907</td><td>18,688</td><td>18,702</td></tr><tr><td>C++</td><td>160,948</td><td>20,000</td><td>20,141</td></tr><tr><td>Python</td><td>206,777</td><td>25,912</td><td>25,837</td></tr><tr><td>JavaScript</td><td>197,529</td><td>24,899</td><td>24,773</td></tr></table>
+
+Table 1: Statistics of the evaluation dataset.
+
+multi-head cross-attention module, a FFN module and an add & norm module. Different from multi-head self-attention module in the encoder, in terms of one token, masked multi-head self-attention in the decoder can only attend to the previous tokens rather than the before and after context. In  $b$ -th cross-attention layer, the input encoding  $(\mathbf{Enc}^{\mathrm{dm}} = (\mathbf{enc}_1^{\mathrm{dm}}, \mathbf{enc}_2^{\mathrm{dm}}, \dots, \mathbf{enc}_{\mathrm{l + m}}^{\mathrm{dm}}))$  is queried by the output of the preceding commit message representations  $\mathbf{Msg} = (\mathbf{msg}_1, \dots, \mathbf{msg}_t)$  obtained by masked multi-head self-attention module.
+
+$$
+D e c _ {\text {h e a d} _ {i} ^ {b}} = \sum_ {j = 1} ^ {l + m} \alpha_ {i j} \left(\mathbf {W} _ {\mathbf {V}} ^ {\mathbf {D e c}} \mathbf {e n c} _ {\mathbf {j}} ^ {\mathbf {b}}\right) \tag {6}
+$$
+
+$$
+D e c _ {e _ {i j}} = \frac {\left(\mathbf {W} _ {\mathbf {Q}} ^ {\mathbf {D e c}} \mathbf {m s g} _ {\mathbf {j}} ^ {\mathbf {b}}\right) ^ {T} \left(\mathbf {W} _ {\mathbf {K}} ^ {\mathbf {D e c}} \mathbf {e n c} _ {\mathbf {i}} ^ {\mathbf {b}}\right)}{\sqrt {d _ {k}}}
+$$
+
+where  $\alpha_{ij} = \frac{\exp\text{Dec}_{ij}}{\sum_{k=1}^{n}\exp\text{Dec}_{ik}}$ ,  $\mathbf{W}_{\mathbf{Q}}^{\mathbf{Dec}}$ ,  $\mathbf{W}_{\mathbf{K}}^{\mathbf{Dec}}$  and  $\mathbf{W}_{\mathbf{V}}^{\mathbf{Dec}}$  are trainable projection matrices for queries, keys and values of the decoder layer. t is the length of preceding commit message.
+
+Next, we use Equation 2 to obtain the hidden states of each decoder layer. In the last decoder layers, we employ a MLP and softmax operator to obtain the generation probability of each commit message token on the vocabulary. Then we use the cross-entropy as the loss function and apply AdamW for optimization.
+
+# 4 Experimental Setup
+
+# 4.1 Dataset
+
+In our experiment, we use a large-scale dataset MCMD (Tao et al., 2021) with five programming languages (PLs): Java, C#, C++, Python and JavaScript. For each PL, MCMD collects commits from the top-100 starred repositories on GitHub and then filters the redundant messages (such as rollback commits) and noisy messages defined in Liu et al. (2018). Finally, to balance the size of data, they randomly sample and retain 450,000 commits for each PL. Each commit contains the code diff, the commit message, the name of the repository,
+
+and the timestamp of commit, etc. To reduce the noise data in the dataset, we further filter out commits that contain multiple files or files that cannot be parsed (such as .jar, .ddl, .mp3, and .apk).
+
+# 4.2 Data pre-processing
+
+The code diff in MCMD are based on line-level code change. To obtain more fine-grained code change, following previous study (Panthaplackel et al., 2020), we use a sequence of span of token-level change actions to represent the code diff. Each action is structured as <action> span of tokens <action end>. There are four <action> types, namely, <keep>, <insert>, <delete>, and <replace>. <keep> means that the span of tokens are unchanged. <insert> means that adding span of tokens. <delete> means that deleting span of tokens. <replace> means that the span of tokens in the old version that will be replaced with different span of tokens in the new version. Thus, we extend <replace> to <replace old> and <replace new> to indicate the span of old and new tokens, respectively. We use difflib<sup>1</sup> to extract the sequence of code change actions.
+
+# 4.3 Hyperparameters
+
+We follow (Tao et al., 2021) to set the maximum lengths of code diff and commit message to 200 and 50, respectively. We use the weight of the encoder of CodeT5-base (Wang et al., 2021b) to initialize the code diff encoders and use the decoder of CodeT5-base to initialize the decoder in Figure 1. The original vocabulary sizes of CodeT5 is 32,100. We add nine special tokens (<keep>, <keep_end>, <insert>, <insert_end>, <delete>, <delete_end>, <replace_old>, <replace_new>, and <replace_end>) and the vocabulary sizes of code and queries become 32109. For the optimizer, we use AdamW with the learning rate 2e-5. The batch size is 32. The max epoch is 20. In addition, we run the experiments 3 times with random seeds 0,1,2 and display the mean value in the paper. The experiments are conducted on a server with 4 GPUs of NVIDIA Tesla V100 and it takes about 1.2 hours each epoch.
+
+# 4.4 Evaluation metrics
+
+We evaluate the quality of the generated messages using four metrics: BLEU (Papineni et al.,
+
+2002), Meteor (Banerjee and Lavie, 2005), Rouge-L (Lin, 2004), and Cider (Vedantam et al., 2015). These metrics are prevalent metrics in machine translation, text summarization, and image captioning. There are many variants of BLEU being used to measure the generated message, We choose B-Norm (the BLEU result in this paper is B-Norm), which correlates with human perception the most (Tao et al., 2021). The detailed metrics calculation can be found in Appendix.
+
+# 4.5 Baselines
+
+We compare RACE with four end-to-end neural-based models, two IR-based methods, two hybrid approaches which combine IR-based techniques and end-to-end neural-based methods, and three pre-trained-based models. Four end-to-end neural-based models include CommitGen (Jiang et al., 2017), CoDiSum (Xu et al., 2019), NMTGen (Loyola et al., 2017), PtrGNCMsg (Liu et al., 2019) and ATOM (Liu et al., 2020). They all train models from scratch. Two IR-based methods are NNGen (Liu et al., 2018) and Lucene (Apache, 2011), they retrieve the similar code diff based on different similarity measurements and reuse the commit message of the similar code diff as the final result. CoRec and ATOM are all hybrid models which combine the neural-based models and IR-based techniques. Three pre-trained models are CommitBERT, CodeT5-small, and CodeT5-base. They are pre-trained on the large parallel code and natural language corpus and fine-tuned on the commit message generation dataset. All baselines except Lucene, CodeT5-small and CodeT5-base are introduced in Section 2. Lucene is a traditional IR baseline, which uses TF-IDF to represent a code diff as a vector and searches the similar code diff based on the cosine similarity between two vectors. CodeT5-small and CodeT5-base are source code pre-trained models and have achieved promising results in many code-related tasks (Wang et al., 2021b). We fine-tune them on MCMD as strong baselines. In addition, we only evaluate ATOM on Java dataset as the current implementation of ATOM only supports Java.
+
+# 5 Experimental Results
+
+# 5.1 How does RACE perform compared with baseline approaches?
+
+To evaluate the effectiveness of RACE, we conduct the experiment by comparing it with the 11
+
+<table><tr><td rowspan="2" colspan="2">Model</td><td colspan="4">Java</td><td colspan="4">C#</td><td colspan="4">C++</td><td colspan="4">Python</td><td colspan="4">JavaScript</td></tr><tr><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td><td>BLEU</td><td>Met.</td><td>Rou.</td><td>Cid.</td></tr><tr><td rowspan="2">IR-based</td><td>NNGen</td><td>19.41</td><td>12.40</td><td>25.15</td><td>1.23</td><td>22.15</td><td>14.77</td><td>26.46</td><td>1.55</td><td>13.61</td><td>9.39</td><td>18.21</td><td>0.73</td><td>16.06</td><td>10.91</td><td>21.69</td><td>0.92</td><td>18.65</td><td>12.50</td><td>24.45</td><td>1.21</td></tr><tr><td>Lucene</td><td>15.61</td><td>10.56</td><td>19.43</td><td>0.94</td><td>20.68</td><td>13.34</td><td>23.02</td><td>1.36</td><td>13.43</td><td>8.81</td><td>16.78</td><td>0.67</td><td>15.16</td><td>9.63</td><td>18.85</td><td>0.85</td><td>17.66</td><td>11.25</td><td>21.75</td><td>1.02</td></tr><tr><td rowspan="4">End-to-end</td><td>CommitGen</td><td>14.07</td><td>7.52</td><td>18.78</td><td>0.66</td><td>13.38</td><td>8.31</td><td>17.44</td><td>0.63</td><td>11.52</td><td>6.98</td><td>16.75</td><td>0.45</td><td>11.02</td><td>6.43</td><td>16.64</td><td>0.42</td><td>18.67</td><td>11.88</td><td>24.10</td><td>1.08</td></tr><tr><td>CoDiSum</td><td>13.97</td><td>6.02</td><td>16.12</td><td>0.39</td><td>12.71</td><td>5.56</td><td>14.40</td><td>0.36</td><td>12.44</td><td>6.00</td><td>14.39</td><td>0.42</td><td>14.61</td><td>8.59</td><td>17.02</td><td>0.42</td><td>11.22</td><td>5.32</td><td>13.26</td><td>0.28</td></tr><tr><td>NMTGen</td><td>15.52</td><td>8.91</td><td>21.13</td><td>0.86</td><td>12.71</td><td>8.11</td><td>17.16</td><td>0.62</td><td>11.57</td><td>7.06</td><td>17.46</td><td>0.51</td><td>11.41</td><td>7.18</td><td>18.43</td><td>0.48</td><td>18.22</td><td>12.07</td><td>24.43</td><td>1.12</td></tr><tr><td>PtrGNCMsg</td><td>17.71</td><td>11.33</td><td>24.32</td><td>0.99</td><td>15.98</td><td>10.18</td><td>21.16</td><td>0.83</td><td>14.06</td><td>9.63</td><td>20.17</td><td>0.63</td><td>15.89</td><td>11.36</td><td>23.49</td><td>0.76</td><td>20.78</td><td>14.52</td><td>27.87</td><td>1.29</td></tr><tr><td rowspan="2">Hybrid</td><td>ATOM</td><td>16.42</td><td>11.66</td><td>22.67</td><td>0.91</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td><td>/</td></tr><tr><td>CoRec</td><td>18.51</td><td>11.26</td><td>24.78</td><td>1.13</td><td>18.41</td><td>11.70</td><td>23.73</td><td>1.12</td><td>14.02</td><td>8.63</td><td>20.10</td><td>0.72</td><td>15.09</td><td>9.60</td><td>22.35</td><td>0.80</td><td>21.30</td><td>13.84</td><td>27.53</td><td>1.40</td></tr><tr><td rowspan="3">Pre-trained</td><td>CommitBERT</td><td>22.32</td><td>12.63</td><td>28.03</td><td>1.42</td><td>20.67</td><td>12.31</td><td>25.76</td><td>1.25</td><td>16.16</td><td>10.05</td><td>19.90</td><td>0.94</td><td>17.29</td><td>11.31</td><td>22.36</td><td>1.01</td><td>23.40</td><td>15.64</td><td>30.51</td><td>1.54</td></tr><tr><td>CodeT5-small</td><td>22.28</td><td>14.16</td><td>29.71</td><td>1.37</td><td>18.92</td><td>11.71</td><td>24.95</td><td>1.05</td><td>16.08</td><td>11.19</td><td>21.60</td><td>0.79</td><td>17.49</td><td>12.46</td><td>24.65</td><td>0.90</td><td>21.97</td><td>14.48</td><td>28.65</td><td>1.42</td></tr><tr><td>CodeT5-base</td><td>22.76</td><td>14.57</td><td>30.23</td><td>1.43</td><td>22.21</td><td>14.51</td><td>29.08</td><td>1.33</td><td>16.73</td><td>11.69</td><td>22.86</td><td>0.85</td><td>17.99</td><td>12.74</td><td>25.27</td><td>0.96</td><td>22.87</td><td>15.12</td><td>29.81</td><td>1.50</td></tr><tr><td rowspan="2">Ours</td><td rowspan="2">RACE</td><td>25.66</td><td>15.46</td><td>32.02</td><td>1.76</td><td>26.33</td><td>16.37</td><td>31.31</td><td>1.84</td><td>19.13</td><td>12.55</td><td>24.52</td><td>1.14</td><td>21.79</td><td>14.68</td><td>28.35</td><td>1.40</td><td>25.55</td><td>16.31</td><td>31.79</td><td>1.84</td></tr><tr><td>↑13%</td><td>↑6%</td><td>↑6%</td><td>↑23%</td><td>↑19%</td><td>↑13%</td><td>↑8%</td><td>↑38%</td><td>↑14%</td><td>↑7%</td><td>↑7%</td><td>↑34%</td><td>↑21%</td><td>↑15%</td><td>↑12%</td><td>↑46%</td><td>↑12%</td><td>↑8%</td><td>↑7%</td><td>↑23%</td></tr><tr><td>Ablation</td><td>RACE -Guider</td><td>23.37</td><td>13.98</td><td>30.01</td><td>1.53</td><td>21.33</td><td>13.56</td><td>27.33</td><td>1.31</td><td>17.43</td><td>12.10</td><td>22.03</td><td>0.95</td><td>19.44</td><td>13.89</td><td>26.4</td><td>1.01</td><td>23.39</td><td>15.64</td><td>30.51</td><td>1.54</td></tr></table>
+
+Table 2: Comparison of RACE with baselines under four metrics on five programming languages. Met., Rou., and Cide. are short for Meteor, Rouge-L, and Cider, respectively. All results are statistically significant (with  $p < 0.01$ ).
+
+basielines including two IR-based approaches, four end-to-end neural-based approaches, two hybrid approaches, and three pre-train-based approaches in terms of four evaluation metrics. The experimental results are shown in Table 2.
+
+We can see that IR-based models NNGen and Lucene generally outperform end-to-end neural models on average in terms of four metrics. It indicates that retrieved similar results can provide important information for commit message generation. CoRec, which combines the IR-based method and neural method, performs better than NNGen on  $\mathrm{C + + }$  and JavaScript dataset but lower than NNGen on Java, C# and Python. This is because CoRec only leverages the information similar code diff at the inference stage. ATOM, which priorities the generated result of the neural-based model and retrieved result of the IR-based method, also outperforms the IR-based approach Lucene and three neural-based models CommitGen, CoDiSum, and NMTGen. Three pre-trained-based approaches outperform other baselines in terms of four metrics on average. CodeT5-base performs best among them on average. Our approach performs the best among all approaches on 5 programming languages in terms of four metrics. This is because RACE treats the retrieved similar commit message as an exemplar and leverages it to guide the neural network model to generate an accurate commit message.
+
+We also give an example of commit messages generated by our approach and the baselines in Figure 2. IR-based methods NNGen and Lucene can retrieve semantically similar but not completely
+
+correct commit message. Specifically, retrieved commit messages contain not only the important semantic ("Filter out unavailable databases") of the current code diff but also the extra information ("Revert"). Neural network models generally capture the action of "add" but fail to further understand the intend of the code diff. The hybrid model CoRec cannot generate the correct commit message either. Our model treats the retrieved result (Revert "Filter out unavailable databases") as an exemplar, and guides the neural network model to generate the correct commit message.
+
+# 5.2 What is the effectiveness of exemplar guider?
+
+We conduct the ablation study to verify the effectiveness of exemplar guider module. Specifically, as shown at the bottom of Figure 1, we directly concatenated the representations of retrieved results and fed them to the decoder to generate commit messages without using the exemplar guider. As shown at the bottom of the Table 2, we can see that the performance of the ablated model (RACE-Guide) degrades in all programming languages in terms of four metrics. It demonstrates the effectiveness of our exemplar guider.
+
+# 5.3 What is the performance when we retrieve  $k$  relevant commits?
+
+We also conduct experiments to recall  $k$  ( $k = 1, 3, 5, 7, 9$ ) most relevant commits to augment the generation model. Specifically, as shown in Figure 1 the relevance of the code diff is measured by the cosine similarity their semantic vectors obtained by
+
+![](images/df3a27eb2a9292c61967484dfc545d7580e17fa9b238f8e959d09153ba050ce1.jpg)  
+Reference Filter out unavailable databases
+
+<table><tr><td colspan="2">Baselines</td></tr><tr><td>NNGen</td><td>Revert “ Filter out unavailable databases”</td></tr><tr><td>Lucene</td><td>Revert “ filter out unavailable databases ”</td></tr><tr><td>CommitGen</td><td>Merge pull request from mistecrunch / UNK</td></tr><tr><td>NMTGen</td><td>Add &lt;unk&gt; to &lt;unk&gt;</td></tr><tr><td>PtrGNCMsg</td><td>Add support for dashboards in database</td></tr><tr><td>CoRec</td><td>Remove &lt;unk&gt;</td></tr><tr><td>CommitBERT</td><td>Add DatabaseFilter ( )</td></tr><tr><td>CodeT5-small</td><td>[database] Add databasefilter to filter all users</td></tr><tr><td>CodeT5-base</td><td>[hotfix] Adding databasefilter to core.py</td></tr><tr><td>RACE</td><td>Stage I : Revert “ Filter out unavailable databases ”Stage II : Filter out unavailable databases</td></tr></table>
+
+Equation 3. Then retrieved  $k$  relevant commits are encoded and fed to the exemplar guider to obtain semantic similarities by Equation 4, respectively. Finally, we weight representations of code diff and similar commit messages according to the semantic similarities and feed them to the decoder to generate commit messages step by step. The experimental results are shown in Figure 3. We can see that the performance is generally stable on different  $k$ . In our future work, we will continue to study alternatives on leveraging the information of the retrieved results, e.g., how many commits to retrieve and how to model the corresponding information.
+
+# 5.4 Can our framework boost the performance of existing models?
+
+We further study whether our framework can enhance the performance of the existing Seq2Seq neural network model in commit message generation. Therefore, we adapt our framework to four Seq2Seq-based models, namely NMTGen (M1), CommitBERT (M2), CodeT5-small (M3) and CodeT5-base (M4). Specifically, we use the encoder of these models as our code diff encoder and obtain the high-dimensional semantic vectors in the retrieval module (Figure 1). In the generation module, we use the encoder of their models
+
+![](images/b4d214e23a6fc1e743eadac9e9166b2bfd94da310cb8e92fa792f7ee376b5cb3.jpg)  
+Figure 3: Performance of models augmented with  $k$  retrieved relevant commits.
+
+![](images/1ddc39bfbd5f0f31491e972522e759c290281c890cdf3cad3b1005a0b64b862e.jpg)  
+Figure 2: An example of generated commit messages. Reference is the developer-written commit message. The results of our approach in stage I and II are returned by the retrieved module and generation module, respectively.  
+Figure 4: Performance gains on four models. The original performance of the models are in yellow and gains from our framework are in green. The percentage value in each bar is the rate of improvement.
+
+to encode input code diffs, similar code diffs, and similar commit messages. We also use the decoder of their models to generate commit messages.
+
+The experimental results are shown in Figure 4, we present the performance of four original models (yellow) and gains (green) from our framework on five programming languages in terms of  $\mathrm{BLEU}^2$  score. Overall, we can see that our framework can improve the performance of all four neural models in all programming languages. Our framework can improve the performance of the original model from  $7\%$  to  $73\%$ . Especially, after applying our framework, the performance of NMTGen has more than  $20\%$  improvement on all programming languages. In addition, Our framework can boost the performance of NMTGen on BLUE, Meteor, Rouge-L, and Cider by  $43\%$ ,  $49\%$ ,  $33\%$ , and  $61\%$  on average, boost CommitBERT by  $11\%$ ,  $9\%$ ,  $11\%$ , and  $12\%$ , boost CodeT5-small by  $15\%$ ,  $14\%$ ,  $11\%$ , and  $26\%$ , and boost CodeT5-base by  $16\%$ ,  $10\%$ ,
+
+<table><tr><td>Model</td><td>Informativeness</td><td>Conciseness</td><td>Expressiveness</td></tr><tr><td>CommitBERT</td><td>1.22 (±1.02)</td><td>2.03 (±1.04)</td><td>2.46 (±0.99)</td></tr><tr><td>NNGen</td><td>1.03 (±1.00)</td><td>1.74 (±1.01)</td><td>2.36 (±0.95)</td></tr><tr><td>NMTGen</td><td>0.74 (±0.92)</td><td>1.56 (±0.93)</td><td>2.11 (±0.94)</td></tr><tr><td>CoRec</td><td>1.05 (±1.09)</td><td>1.80 (±1.05)</td><td>2.43 (±0.88)</td></tr><tr><td>RACE</td><td>2.49 (±1.10)</td><td>3.08 (±0.96)</td><td>2.85 (±0.84)</td></tr></table>
+
+Table 3: Results of human evaluation (standard deviation in parentheses).
+
+$8\%$ , and  $32\%$
+
+# 5.5 Human evaluation
+
+We also conduct a human evaluation by following the previous works (Moreno et al., 2013; Panichella et al., 2016; Shi et al., 2021b) to evaluate the semantic similarity of the commit message generated by RACE and four baselines NNGen, NMTGen, CommitBERT, and CoRec. The four baselines are IR-based, end-to-end neural network-based, hybrid, and pre-trained-based approaches, respectively. We randomly choose 50 code diff from the testing sets and their commit message generated by four approaches. Finally, we sample  $250 < \text{code diff}$ , commit message> pairs to score. Specifically, we invite 4 volunteers with excellent English ability and more than three years of software development experience. Each volunteer is asked to assign scores from 0 to 4 (the higher the better) to the generated commit message from the three aspects: Informativeness (the amount of important information about the code diff reflected in the commit message), Conciseness (the extend of extraneous information included in the commit message), and Expressiveness (grammaticality and fluency). Each pair is evaluated by four volunteers, and the final score is the average of them.
+
+To verify the agreement among the volunteers, we calculate the Krippendorff's alpha (Hayes and Krippendorff, 2007) and Kendall rank correlation coefficient (Kendall's Tau) values (Kendall, 1945). The value of Krippendorff's alpha is 0.90 and the values of pairwise Kendall's Tau range from 0.73 to 0.95, which indicates that there is a high degree of agreement between the 4 volunteers and that scores are reliable. Table 3 shows the result of human evaluation. RACE is better than other approaches in Informative, Conciseness, and Expressiveness, which means that our approach tends to generate concise and readable commit messages with more
+
+comprehensive semantics. In addition, we confirm the superiority of our approach using Wilcoxon signed-rank tests (Wilcoxon et al., 1970) for the human evaluation. Results show that the improvement of RACE over other approaches is statistically significant with all p-values smaller than 0.05 at  $95\%$  confidence level.
+
+# 6 Conclusion
+
+This paper proposes a new retrieval-augmented neural commit message generation method, which treats the retrieved similar commit message as an exemplar and uses it to guide the neural network model to generate an accurate and readable commit message. Extensive experimental results demonstrate that our approach outperforms recent baselines and our framework can significantly boost the performance of four neural network models. Our data, source code and Appendix are available at https://github.com/DeepSoftwareAnalytics/RACE.
+
+# Limitations
+
+We have identified the following main limitations:
+
+Programming Languages. We only conduct experiments on five programming languages. Although in principle, our framework is not specifically designed for certain languages, models perform differently in different programming languages. Therefore, more experiments are needed to confirm the generality of our framework. In the future, we will extend our study to other programming languages.
+
+Code base. Compared with purely neural network-based models, our method needs a code base to retrieve the most similar example from that. This limitation is inherited from IR-based techniques.
+
+Training Time. In addition to modeling the information of input code diffs, our model needs to retrieve similar diffs and encode them. Thus, our model takes a long time to train (about 35 hours to train the model).
+
+Long Code Diffs. Longer code diffs may contain more complex semantics or behaviors. Long diffs (over 512 tokens) are truncated in our approach and some information would be lost. In our future work, we will design mechanisms to better handle long diffs.
+
+# Acknowledgement
+
+We thank reviewers for their valuable comments on this work. This research was supported by National Key R&D Program of China (No. 2017YFA0700800). We would like to thank Jiaqi Guo and Wenchao Gu for their valuable suggestions and feedback during the work discussion process. We also thank the participants of our human evaluation for their time.
+
+# References
+
+Apache. 2011. Apache lucene.  
+Satanjeev Banerjee and Alon Lavie. 2005. METEOR: an automatic metric for MT evaluation with improved correlation with human judgments. In IEEvaluation@ACL.  
+Mike Barnett, Christian Bird, João Brunet, and Shuvendu K. Lahiri. 2015. Helping developers help themselves: Automatic decomposition of code review changesets. In ICSE (1), pages 134-144. IEEE Computer Society.  
+Raymond P. L. Buse and Westley Weimer. 2010. Automatically documenting program changes. In ASE, pages 33-42. ACM.  
+Luis Fernando Cortes-Coy, Mario Linares Vásquez, Jairo Aponte, and Denys Poshyvanyk. 2014. On automatically generating commit messages via summarization of source code changes. In SCAM, pages 275-284. IEEE Computer Society.  
+Martin Dias, Alberto Bacchelli, Georgios Gousios, Damien Cassou, and Stephane Ducasse. 2015. Untangling fine-grained code changes. In SANER, pages 341-350. IEEE Computer Society.  
+Jinhao Dong, Yiling Lou, Qihao Zhu, Zeyu Sun, Zhilin Li, Wenjie Zhang, and Dan Hao. 2022. Fira: Fine-grained graph-based code change representation for automated commit message generation.  
+Lun Du, Xiaozhou Shi, Yanlin Wang, Ensheng Shi, Shi Han, and Dongmei Zhang. 2021. Is a single model enough? mucos: A multi-model ensemble learning approach for semantic code search. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management, pages 2994-2998.  
+Robert Dyer, Hoan Anh Nguyen, Hridesh Rajan, and Tien N. Nguyen. 2013. Boa: a language and infrastructure for analyzing ultra-large-scale software repositories. In ICSE, pages 422-431. IEEE Computer Society.  
+Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020.
+
+Codebert: A pre-trained model for programming and natural languages. In EMNLP (Findings), volume EMNLP 2020 of Findings of ACL, pages 1536-1547. Association for Computational Linguistics.  
+Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. 2018. Deep code search. In ICSE, pages 933-944. ACM.  
+Andrew F Hayes and Klaus Krippendorff. 2007. Answering the call for a standard reliability measure for coding data. Communication methods and measures, 1(1):77-89.  
+Yuan Huang, Nan Jia, Hao-Jie Zhou, Xiangping Chen, Zibin Zheng, and Mingdong Tang. 2020. Learning human-written commit messages to document code changes. J. Comput. Sci. Technol., 35(6):1258-1277.  
+Yuan Huang, Qiaoyang Zheng, Xiangping Chen, Yingfei Xiong, Zhiyong Liu, and Xiaonan Luo. 2017. Mining version control system for automatically generating commit comment. In ESEM, pages 414-423. IEEE Computer Society.  
+Siyuan Jiang, Ameer Armaly, and Collin McMillan. 2017. Automatically generating commit messages from diffs using neural machine translation. In ASE.  
+Tae Hwan Jung. 2021. Commitbert: Commit message generation using pre-trained programming language model. In Proceedings of the 1st Workshop on Natural Language Processing for Programming (NLP4Prog 2021), pages 26-33.  
+Maurice G Kendall. 1945. The treatment of ties in ranking problems. Biometrika, 33(3):239-251.  
+Patrick S. H. Lewis, Ethan Perez, Aleksandra Pik-tus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Kuttler, Mike Lewis, Wen-tau Yih, Tim Roektaschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge-intensive NLP tasks. In NeurIPS.  
+Chin-Yew Lin. 2004. ROUGE: A package for automatic evaluation of summaries. In Text Summarization Branches Out.  
+Qin Liu, Zihe Liu, Hongming Zhu, Hongfei Fan, Bowen Du, and Yu Qian. 2019. Generating commit messages from diffs using pointer-generator network. In MSR, pages 299-309. IEEE / ACM.  
+Shangqing Liu, Cuiyun Gao, Sen Chen, Lun Yiu Nie, and Yang Liu. 2020. ATOM: commit message generation based on abstract syntax tree and hybrid ranking. TSE, PP:1-1.  
+Zhongxin Liu, Xin Xia, Ahmed E. Hassan, David Lo, Zhenchang Xing, and Xinyu Wang. 2018. Neural-machine-translation-based commit message generation: how far are we? In ASE, pages 373-384. ACM.  
+Ilya Loshchilov and Frank Hutter. 2019. Decoupled weight decay regularization. In ICLR.
+
+Pablo Loyola, Edison Marrese-Taylor, and Yutaka Matsuo. 2017. A neural architecture for generating natural language descriptions from source code changes. In ACL (2), pages 287-292. Association for Computational Linguistics.  
+Laura Moreno, Jairo Aponte, Giriprasad Sridhara, Andrian Marcus, Lori L. Pollock, and K. Vijay-Shanker. 2013. Automatic generation of natural language summaries for java classes. In ICPC, pages 23-32. IEEE Computer Society.  
+Lun Yiu Nie, Cuiyun Gao, Zhicong Zhong, Wai Lam, Yang Liu, and Zenglin Xu. 2021. Coregen: Contextualized code representation learning for commit message generation. Neurocomputing, 459:97-107.  
+Sebastiano Panichella, Annibale Panichella, Moritz Beller, Andy Zaidman, and Harald C. Gall. 2016. The impact of test case summaries on bug fixing performance: an empirical investigation. In ICSE, pages 547-558. ACM.  
+Sheena Panthaplackel, Pengyu Nie, Milos Gligoric, Junyi Jessy Li, and Raymond J. Mooney. 2020. Learning to update natural language comments based on code changes. In ACL, pages 1853-1868. Association for Computational Linguistics.  
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. Bleu: a method for automatic evaluation of machine translation. In ACL.  
+Jinfeng Shen, Xiaobing Sun, Bin Li, Hui Yang, and Jiajun Hu. 2016. On automatic summarization of what and why information in source code changes. In COMPSAC, pages 103-112. IEEE Computer Society.  
+Ensheng Shi, Wenchao Gub, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2022a. Enhancing semantic code search with multimodal contrastive learning and soft data augmentation. arXiv preprint arXiv:2204.03293.  
+Ensheng Shi, Yanlin Wang, Lun Du, Junjie Chen, Shi Han, Hongyu Zhang, Dongmei Zhang, and Hongbin Sun. 2022b. On the evaluation of neural code summarization. In ICSE.  
+Ensheng Shi, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2021a. Cast: Enhancing code summarization with hierarchical splitting and reconstruction of abstract syntax trees. In EMNLP.  
+Ensheng Shi, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2021b. CAST: enhancing code summarization with hierarchical splitting and reconstruction of abstract syntax trees. In EMNLP (1), pages 4053-4062. Association for Computational Linguistics.
+
+Wei Tao, Yanlin Wang, Ensheng Shi, Lun Du, Shi Han, Hongyu Zhang, Dongmei Zhang, and Wenqiang Zhang. 2021. On the evaluation of commit message generation models: An experimental study. In ICSME.  
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In NIPS, pages 5998-6008.  
+Ramakrishna Vedantam, C. Lawrence Zitnick, and Devi Parikh. 2015. Cider: Consensus-based image description evaluation. In CVPR.  
+Haoye Wang, Xin Xia, David Lo, Qiang He, Xinyu Wang, and John Grundy. 2021a. Context-aware retrieval-based deep commit message generation. ACM Trans. Softw. Eng. Methodol., 30(4):56:1-56:30.  
+Yanlin Wang, Lun Du, Ensheng Shi, Yuxuan Hu, Shi Han, and Dongmei Zhang. 2020. Cocogum: Contextual code summarization with multi-relational gnn on ums. Technical report, Microsoft, MSR-TR-2020-16. [Online].  
+Yue Wang, Weishi Wang, Shafiq R. Joty, and Steven C. H. Hoi. 2021b. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. In EMNLP (1), pages 8696-8708. Association for Computational Linguistics.  
+Bolin Wei, Yongmin Li, Ge Li, Xin Xia, and Zhi Jin. 2020. Retrieve and refine: exemplar-based neural comment generation. In 2020 35th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 349-360. IEEE.  
+Frank Wilcoxon, SK Katti, and Roberta A Wilcox. 1970. Critical values and probability levels for the wilcoxon rank sum test and the wilcoxon signed rank test. Selected tables in mathematical statistics, 1:171-259.  
+Shengbin Xu, Yuan Yao, Feng Xu, Tianxiao Gu, Hanghang Tong, and Jian Lu. 2019. Commit message generation for source code changes. In *IJCAI*, pages 3975-3981. ijcai.org.  
+HongChien Yu, Chenyan Xiong, and Jamie Callan. 2021. Improving query representations for dense retrieval with pseudo relevance feedback. In CIKM, pages 3592-3596. ACM.  
+Jian Zhang, Xu Wang, Hongyu Zhang, Hailong Sun, and Xudong Liu. 2020. Retrieval-based neural source code summarization. In ICSE.

2203.02xxx/2203.02700/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:883454eba91f283c141045ba1d58e9e61574a8df1ae6e353ecb46c51a4716424
+size 440088

2203.02xxx/2203.02719/6a2a0cc6-43cc-4438-b5c9-38412d95a76d_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76a78eaae70a49c0be5811ba78d2b8d945da7523ba15b047ef38a7797ef02e74
+size 5181418

2203.02xxx/2203.02719/full.md

@@ -0,0 +1,445 @@
+# DroidRL: Feature Selection for Android Malware Detection with Reinforcement Learning\*
+
+Yinwei Wu $^{a}$ , Meijin Li $^{a}$ , Qi Zeng $^{c}$ , Tao Yang $^{c}$ , Junfeng Wang $^{c}$ , Zhiyang Fang $^{b,*}$  and Luyu Cheng $^{d}$
+
+aCollege of Software Engineering, Sichuan University, Chengdu, China  
+$^{b}$ School of Cyber Science and Engineering, Sichuan University, Chengdu, China  
+$^{c}$ College of Computer Science, Sichuan University, Chengdu, China  
+$^{d}$ School of Business, Sichuan University, Chengdu, China
+
+# ARTICLE INFO
+
+Keywords:
+
+Reinforcement Learning
+
+Android Malware Detection
+
+Feature Selection
+
+RNN
+
+Sequence Processing
+
+# ABSTRACT
+
+Due to the completely open-source nature of Android, the exploitable vulnerability of malware attacks is increasing. Machine learning, leading to a great evolution in Android malware detection in recent years, is typically applied in the classification phase. Since the correlation between features is ignored in some traditional ranking-based feature selection algorithms, applying wrapper-based feature selection models is a topic worth investigating. Though considering the correlation between features, wrapper-based approaches are time-consuming for exploring all possible valid feature subsets when processing a large number of Android features. To reduce the computational expense of wrapper-based feature selection, a framework named DroidRL is proposed. The framework deploys DDQN algorithm to obtain a subset of features which can be used for effective malware classification. To select a valid subset of features over a larger range, the exploration-exploitation policy is applied in the model training phase. The recurrent neural network (RNN) is used as the decision network of DDQN to give the framework the ability to sequentially select features. Word embedding is applied for feature representation to enhance the framework's ability to find the semantic relevance of features. The framework's feature selection exhibits high performance without any human intervention and can be ported to other feature selection tasks with minor changes. The experiment results show a significant effect when using the Random Forest as DroidRL's classifier, which reaches  $95.6\%$  accuracy with only 24 features selected.
+
+# 1. INTRODUCTION
+
+Android is the fastest-growing computing platform on the mobile terminal. In 2021, there were 1.39 billion smartphones manufactured worldwide, and Android dominated the global market by  $72.2\%$ . However, as an open-source operating system, Android has been attacked by various malware. According to the report released by Qianxin Threat Intelligence Center [33], a total of 2.3 million samples of malicious programs were intercepted on the Android platform in 2020, with an average of 6,301 new samples of malicious programs every day. The AdbMiner Mining Trojan family is active in attacks, capturing tens of thousands of Internet of things devices worldwide, and the number of Internet of things devices captured in China is close to 1000. Therefore, Android malware becomes so serious that many researchers endeavor to seek effective detection methods.
+
+The advent of machine learning had a significant impact on Android malware detection for the classification stage. Currently, advanced Android malware detection approaches can be categorized into static analysis [19] [44] and dynamic analysis [19] [31]. Some researchers utilize state-of-the-art machine learning models like deep learning [6], online learning [28] or ensemble learning [23] to identify multi-class attacks effectively in the Android environment.
+
+Eliminating redundant or irrelevant features is a significant procedure of machine learning. Babaagba et al. [5] demonstrated the influence of feature engineering in Android malware detection by contrasting the performance of the model with or without feature selection algorithms applied.
+
+As the commonly applied feature selection approach, filter-based Android feature selection models [36] [29] [46] are unable to utilize the feedback from the accuracy of the classifier in Android malware detection, consequently the correlation information between different features obtained from the classifier is ignored. However, the number of
+
+Table 1 Feature subsets selection in Android  
+
+<table><tr><td>Method</td><td>Advantage</td><td>Disadvantage</td><td>Algorithm</td></tr><tr><td>Filter</td><td>Fast, lower computational cost</td><td>Without considering feature relevance</td><td>Correlation-based Feature Selection (CFS), The Consistency-based Filter [10], Information Gain [24], ReliefF [37]</td></tr><tr><td>Wrapper</td><td>Capture feature relevance, optimize the predictor</td><td>High computational cost</td><td>FFSR [18], Wrapper SubsetEval [42]</td></tr></table>
+
+possible combinations of these features is so large that it is not infeasible for an exhaustive search in a wrapper-based approach [17], which always incurs a high computational expense.
+
+In this paper, a wrapper-based feature selection model using DDQN [26], DroidRL, is proposed to automatically select valid Android feature subsets. The main contributions of this paper are summarized as follows:
+
+(1) Reinforcement learning (RL) is leveraged in the wrapper-based feature selection to address the problem of inexhaustible feature subsets of the raw Android features. Reinforcement learning and exploration-exploitation policy are utilized in DroidRL to explore an optimal feature subset for malware detection.
+
+(2) DroidRL presents an extensible prototype of a feature reduction algorithm for machine learning in other scenarios. A highly efficient approach is proposed in this paper for researchers to reprocess raw features on their datasets when machine learning models are used. DroidRL takes advantage of the reinforcement learning nature to automatically perform feature selection for dimension reduction, sufficient to replace the burdensome manual feature engineering in the malware detection task.
+
+(3) The feature dimension is notably reduced (1083 to 24) using the DroidRL framework while maintaining high accuracy  $(95.6\%)$ . Extensive experiments demonstrate that the DroidRL framework performs better than the traditional feature selection methods, improving detection performance on a variety of classifiers.
+
+The paper is structured as follows: Section 2 gives an introduction to related works on feature selection for Android malware and reinforcement learning in cyber security. Section 3 describes the fundamental principles of the DroidRL applied in feature selection in Android malware detection. Section 4 introduces the training process of the DroidRL. Section 5 presents the dataset to carry out the comparative experiment, the feature extraction method, and the data preprocessing process. Section 6 discusses the results of the experiment.
+
+# 2. RELATED WORK
+
+# 2.1. Feature Selection for Android Malware Detection
+
+Feature selection is the process of selecting a subset from the original feature set to improve detection efficiency. Determined by whether independent of the accuracy of the classifier, feature selection algorithms can be categorized into filter and wrapper based algorithms. Table 1 depicts the traits of each category and the difference between them. Yu and Liu [20] introduced a correlation-based filter (FCBF) feature selection which made improvements in the traditional filter-based approach for reducing the redundancy among relevant features. Priya et al. [32] detected Android malware using an improved filter-based technique; the k-nearest neighbor (KNN) based Relief algorithm. Huda et al. [17] applied the filter's ranking score in the wrapper selection process and combined the properties of wrapper and filters with API call statistics to detect malware based on the nature of infectious actions. Xu et al. [43] employed correlation-based feature selection (CFS)[14] to identify and remove the redundant features, reducing 121,621 to 5,000 features. Yuan et al. [45] utilized only features that deep learning essentially exploited to characterize malware and reached  $96.76\%$  detection accuracy. Allix et al. [1] created basic blocks as features, sequences of instructions in the controlflow graph with only one entry point and one exit point, thus representing the smallest piece of the program that was always executed altogether
+
+The typical filter-based feature selection algorithm is ranking-based. Each feature is assigned a score according to its importance and then the top N features are selected as input for the classification stage after ranking all the features. Huang et al. [16] proposed a parameterless feature ranking approach for feature selection and a modified greedy feature selection algorithm. Wang et al. [41] ranked individual permissions based on the risk of single permission
+
+and the group of permissions. Mahindru, Arvind, and Sangal [21] applied six different feature ranking approaches to select significant features, including Gain-ratio feature selection, Chi-Square, Information-gain, and logistic regression analysis. In another experiment [22] they combined six distinct kinds of feature ranking and four distinct kinds of feature subset selection approaches to select the valid feature subsets.
+
+Traditional machine learning models can be optimized to select valid feature subsets. Youn [35] presented an algorithm based on support vector machines (SVM) for feature selection to decrease the computation time. Priya, Varna, and Visalakshi [32] proposed KNN based relief algorithm for feature selection. The optimized SVM algorithm was applied for malware detection with the result equivalent to the performance of neural network.
+
+The state-of-the-art machine learning algorithms like the genetic algorithm [12] and neural network [40] are also used in feature subsets selection. For neural networks, the score derived from the sum of the softmax weights of the input features can be adopted as an evaluation indicator to select valid feature subsets.
+
+From the above discussion, the conclusion can be reached that little research utilizes the feedback from the accuracy of the classifier in Android malware detection. Filter-based feature selection is less computationally expensive compared with wrapper-based feature selection, but the relevance between different features is ignored, which can consequently choose a large number of redundant features while processing high-dimension feature vectors. To make a improvement in the efficiency of the malware detection classifier, the problem of inexhaustible feature combinations in selected valid subsets in the previous wrapper-based method should be addressed.
+
+# 2.2. Reinforcement Learning in Cyber Security
+
+The prevailing algorithms of reinforcement learning are Q-learning [25], Deep Q Network (DQN) [26] and Double Deep Q Network (DDQN) [15]. DQN is introduced by Mnih et al. to address the problem of the difficulty to use Q-table for high-dimensional, continuous state and action space. DDQN made a noteworthy improvement on DQN in the training algorithm. The generation method of target Q value is modified in DDQN [15] to deal with the overestimation of the Q value of action in traditional DQN.
+
+Applications of reinforcement learning in software security achieved significant improvements in recent years. CyberBattleSim [38] implemented a automated defender agent that detected and mitigated ongoing attacks based on pre-defined probabilities of success, with the simulation environment parameterized by fixed network topology and a set of predefined vulnerabilities.
+
+Especially in virus detection, reinforcement learning has been commonly applied in malware classification [7] or adversarial sample generating [11] [34]. Fang et al. [11] trained an AI agent to automatically generate adversarial samples by rewarding it if the modified malware escaped the classifier detection. Rathore et al. [34] generated malware using reinforcement learning for maximizing fooling rate while making minimum modifications to the Android application. To address the problem of the slow learning rate in the game with the high dimension of Q-learning, Wan et al. [39] applied deep Q-network technique with a deep convolutional neural network in mobile malware detection, which initiates the quality values based on the malware detection experience.
+
+In this work, by combing the advantages of using existing experience while automatically exploring other optimal subsets in reinforcement learning and the utilization of feature relevance in wrapper-based feature selection, DroidRL tackled the problems of the traditional feature selection algorithm to make the feature selection phase faster and the malware classification more efficient.
+
+# 3. DROIDRL FRAMEWORK
+
+For the DroidRL framework, the primary task is to train a learning agent to sequentially choose valid Android feature subsets by interacting with the environment and utilizing its learned knowledge. This section describes how the DroidRL framework achieves its goal.
+
+# 3.1. Overview of DroidRL
+
+Figure 1 shows the schematic diagram of the DroidRL. The core part of the DroidRL framework is built up by the DDQN-based decision network. In each step, the autonomous agent independently carries out an action decided by the decision network, to select one feature into its observed state from the environment using their prior knowledge. To evaluate the quality of the feature subset and differentiation of the selected individual features, the reward of the action produced from the malware classifier is determined by the malware classification accuracy using selected features as input. Furthermore, the state of the agent, the chosen action, and the reward of this epoch are saved in the replay
+
+![](images/d32eb178e2ab103fe40c2f5352e043e1451f50a2c0d2e5857e627d0a60fd44c9.jpg)  
+Figure 1: DroidRL for feature selection in Android malware detection
+
+memory for training the decision network. The exploration-exploitation policy is enhanced to address the problem of computational expense due to inexhaustible feature subsets.
+
+# 3.2. Key Components in Reinforcement Learning
+
+(1) Environment: The environment is the place for the agent to explore and get feedback.
+
+In our framework, the environment contains all candidate features and is responsible for putting the agent's current state into the malware classifier after each action is executed. The accuracy of the classification will be returned to the agent as reward. The total number of given features and the length of the valid feature subsets that need to select are defined in environment. When the agent has selected enough features according to the declared length of the valid feature subset, the environment instructs the agent to end this round, return the final reward, and reset itself.
+
+(2) Action: Action is the critical step the agent in reinforcement learning needs to take from action space based on its experience and current state.
+
+In the DroidRL framework, action space contains features in the raw feature sets extracted through decompiled APK files. The state of the agent describes the currently selected features as the result of a series of actions. The primary task of the agent is to find the optimal feature subset that is highly distinguishable between malware and benign Android software.
+
+For each action in the DroidRL framework, one unselected feature is added to the state.  $\varepsilon$ -Greedy algorithm is employed to make the agent trade-off between exploration and exploitation. Each action is explored with the probability of  $\varepsilon$ , while the action with the largest Q value is exploited with the probability of  $1 - \varepsilon$ . Aimed to enable the agent in the training phase to explore more at the early stage and exploit more using the existing experience at the later stage, some improvements are made to  $\varepsilon$ -Greedy algorithm as displayed in Equation 1, where episode is the current training round,  $E$  is the total training round, and  $P$  is a probability parameter between 0 and 1. More details are given in section 4.
+
+$$
+\varepsilon = 1 - \frac {\text {e p i s o d e}}{E} \times p \tag {1}
+$$
+
+(3) Reward: The reward is feedback as a result of interaction between the agent and the environment through taking action.
+
+In this paper, the reward is determined by the accuracy of the Android malware classifier, with the selected features in agent's current state as input. The agent enters a state  $s$  after executing feature selection action  $a$ . Then the reinforcement learning environment returns the corresponding reward from the malware classifier to evaluate the action value function  $Q$ .
+
+With the goal to obtain the highest Q value by action, the agent can consequently find the valid feature combination devoted to the highest accuracy. In Equation 2,  $s$  and  $a$  respectively represent the current state and the action taken at the current step.  $r$  is the obtained reward,  $s'$  represents the next state reached by the agent, and  $a'$  refers to the action that can obtain the highest Q value in the next state. As  $a'$  can also be calculated by Q function, the original formula is equivalent to Equation 3, where  $\theta_{1}$  and  $\theta_{2}$  represent the parameters of two networks in DDQN respectively.
+
+$$
+Q _ {(s, a)} = r + \gamma Q \left(s ^ {\prime}, a ^ {\prime}\right) \tag {2}
+$$
+
+$$
+Q _ {(s, a, \theta_ {1})} = r + \gamma Q \left(s ^ {\prime}, \underset {a} {\arg \max } Q \left(s ^ {\prime}, a, \theta_ {2}\right), \theta_ {1}\right) \tag {3}
+$$
+
+# 3.3. Decision Network
+
+In the DroidRL, the decision network is the brain of the agent. When exploitation is performed, the agent puts the current state represented by a vector into DroidRL's decision network, then the decision network returns the guidance of the next action to the agent.
+
+It is worth mentioning that the length of the agent's state is continuing to grow. It causes the input of the decision network to have an unfixed length. DroidRL's decision network needs to be specially designed since the input to a neural network is normally in constant shape. RNN is a kind of neural network widely used in natural language processing. Because of the unfixed length of natural languages, RNN-like networks are designed to accept input of indeterminate length. For this reason, DroidRL's decision network adopts RNN and its variants.
+
+The DroidRL also applies some tricks that can do help to the training effect and the ability of the feature selection.
+
+(1)Word Embedding: The input of our decision network is a sequence of selected features. Instead of being presented as the one-hot vector, word embedding is applied to process the input. If the one-hot vector is used to represent the sequence of the features, the entire input matrix will be large and sparse. It will lead to a huge amount of computation and storage. Additionally, there is no semantic information when features are represented by one-hot vectors, which is not conducive for the decision network to find the correlation between features. Applying word embedding into DroidRL's decision network can improve the framework in the following two aspects:
+
+1. Compressing a one-hot vector into a denser one. Word embedding greatly reduces the input dimension and improves the training speed of the model.  
+2. Compressed feature vectors are more semantic. The DroidRL's main task is to select an optimal subset of features. After word embedding is added to the decision network, the DroidRL can cluster features in high dimension space according to their semantics. Then it can better find the features that can be combined with the current selected features.
+
+(2)Features Ordering: There is a special consideration for applying natural language processing methods to DroidRL feature selection. Natural language is sequential in nature which means replacing two words in a sentence can make the sentence confusing and meaningless. However, in feature selection, replacing any two selected features in the feature sequence should not have any influence on the decision network making its decision. The input state [1,2,3] and the input state [1,3,2] are identical in meaning since they contain the same features and should produce the same output in the decision network. Exchanges positions of any two features in the input state should not influence the result. This character of feature selection differs from that of natural language. If this particular property is not addressed, it may have a negative impact on RNN-like decision network learning.
+
+A trick is applied to deal with this problem. Before the features are fed into the decision network, they are sorted by index. In this way, the same feature set can be guaranteed to produce only one input regardless of the order of feature selection.
+
+After applying the above tricks, the ultimate decision network structure is shown in Figure 2. The agent puts its state, a sequence that represents the selected features, into the decision network. The first layer of the decision network
+
+![](images/89515a8a63e35d11f44aac7facdac320f24d527e230ff3baac0b99fe3c76afbc.jpg)  
+Figure 2: DroidRL's Decision Network. The decision network takes in the agent's current state and predicts a new feature as action.
+
+is the embedding layer. Features represented by one-hot vectors go through the embedding layer and become more dense vectors. These vectors then are fed into the RNN-like network and finally enter a fully connected layer and a softmax layer.
+
+# 4. TRAINING PHASE
+
+The DroidRL training process is elaborated in this section. The training algorithm and evaluating algorithm are illustrated in Algorithm 1.
+
+To overcome the problems of correlated data and non-stationary distribution of training data, replay memory is adopted in DroidRL. Before training begins, DroidRL obtains some initial samples by running warm-up episodes and feeds them into the replay memory. At the beginning of each training episode, the state of the agent is cleared and then the agent begins to select features. Each episode ends after a sufficient number of features have been selected. During the training episodes, a strategy that traded off between exploration and exploitation is adopted. As depicted in equation (1), the agent has a very high probability of exploration at the beginning but more possibility of exploitation as the increase of episode.
+
+In the case of exploration, the agent randomly selects a feature (that is not in its state) in an action. Exploration allows the agent to try more possible feature combinations and choice space.
+
+When the exploitation policy is executed, the agent uses previous experience to select the optimal feature. Instead of randomly selecting a feature, the agent puts its current state into the decision network and gets a vector of the same length as the feature dictionary that denotes the confidence of each feature. The agent takes the feature with the highest confidence as action. If the highest confidence feature has already been selected, the agent takes the second highest one instead, and so on. As mentioned before, after each time a new feature is added to the state, the state is reordered to ensure consistency of feature set representation. After each action is taken, the features in the state are used to classify malware and benign. The accuracy of the classification as the reward combines with the previous state and the current state after taking the action are put into the replay memory. The agent continues exploit and explore until enough features are selected.
+
+After training all training episodes, the agent will finally run an evaluation episode. In this episode, each step of agent will utilize what it has learned during the training phase. The output of this episode is the final optimal feature subset.
+
+# 5. EXPERIMENT SETUP
+
+This section provides information on the hardware environment for training DroidRL, our dataset, and hyperparameters setting.
+
+# 5.1. Training Environment
+
+We performed all the experiments on the server with single Tesla V100 GPU and a CPU with two cores. The GPU was used to accelerate the training of decision network in DroidRL, while the training and prediction of the classifiers in DroidRL used CPU only. After the training process, DroidRL's classifier can be extracted separately for testing or deployed on any hardware that capable of running machine learning algorithms.
+
+Algorithm 1: training and evaluation process  
+Data: length of feature dictionary  $N$  , number of features to be selected  $F$  total training episode  $E$  replay memory warm-up episodes  $M$  , initial replay memory rmp, initial network weights  $\theta_{1},\theta_{2}$  , initial probability of exploration  $\varepsilon$  Result: Optimal feature subset for malware detection   
+1 initialization;   
+2 for  $m\gets 1$  to  $M$  do   
+3 sample some random states and feed into rmp;   
+4 end   
+5 for episode  $\leftarrow 1$  to  $E$  do   
+6 state  $\leftarrow$  an empty array   
+7 for  $f\gets 1$  to  $F$  do   
+8 previous state  $\leftarrow$  state;   
+9 with probability  $\varepsilon$  random choose a feature and put it into the state;   
+10 or   
+11 input the state to Decision network and get an N dimension vector, find the index of the max value in the vector and put it into the state;   
+12 calculate reward of the state;   
+13 put reward, previous state, state into rpm;   
+14 end   
+15 if episode mod Network_Learn_Frequency  $\equiv = 0$  then sampling some samples from rpm and update  $\theta_{1}$  .   
+17 end   
+18 if episode mod Sync_Frequency  $\equiv = 0$  then sampling some samples from rpm and learning; Synchronize  $\theta_{1},\theta_{2}$  .   
+21 end   
+22 update  $\varepsilon$  by equation (1);   
+23 end   
+24 start evaluating;   
+25 optimal state  $\leftarrow$  an empty array;   
+26 for  $f\gets 1$  to  $F$  do   
+27 input the current optimal state to Decision network and get an N dimension vector, find the index of the max value in the vector and put it into the optimal state;   
+28 end   
+29 recalculate final Reward of the optimal state;   
+30 return optimal state, final Reward;
+
+# 5.2. Dataset
+
+DroidRL's dataset contains 5000 benign samples from AndroZoo and 5560 malware from Drebin to train and test the model. Both data sources are universally utilized in recent years' research focusing on Android malware detection, which renders it easier to carry out comparison experiments with other feature selection methods. AndroZoo [2] updates the collection of 16,000k different APKs from several sources including Google Play, with each application analyzed by different AntiVirus products to label the Malware. Malware samples in this research are mainly selected from Drebin [4], a commonly used dataset that contains 5,560 applications from 179 different malware families.
+
+Static analysis is applied in this work, extracting the permissions, intent actions, and opcode as original features from android samples decompiled by APKtool and Androguard for further reinforcement learning based feature selection.
+
+In total 457 permissions and 126 intent actions that are typically considered to be highly relevant to the malicious behavior of Android applications, are chosen in this paper to construct original feature set. Permissions indicate what sensitive user data (e.g., contacts and SMS) need to be accessed by an application, essential in Android malware
+
+![](images/c81221743fbcdde24b76409cede7c9663c76b42ff72a5fe71d394878b5e9c35a.jpg)  
+Figure 3: Overview of DroidRL
+
+Table 2 Dalvik Instruction Transformation Table  
+
+<table><tr><td>Letter</td><td>Dalvik Instruction</td></tr><tr><td>M</td><td>move, move/from16, move/16, move-wide, move-wide/from16, move-result, move-wide/16, move-object, move-object/from16, move-object/16 ...</td></tr><tr><td>R</td><td>return-void, return, return-wide, return-object</td></tr><tr><td>G</td><td>goto, goto/16, goto/32</td></tr><tr><td>I</td><td>if-eq, if-ne, if-lt, if-ge, if-gt, if-le, if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez</td></tr><tr><td>T</td><td>aget, aget-wide, aget-object, aget-boolean, aget-byte, aget-char, aget-short, iget, iget-wide, iget-object, iget-boolean, iget-byte, iget-char ...</td></tr><tr><td>P</td><td>aput, aput-wide, aput-object, aput-boolean, aput-byte, aput-char, aput-short, iput, iput-wide, iput-object, iput-boolean, iput-byte, iput-char...</td></tr><tr><td>V</td><td>invoke-virtual, invoke-super, invoke-direct, invoke-static, invoke-interface, invoke-virtual/range, invoke-super/range, invoke-direct/range...</td></tr></table>
+
+detection. Intent actions are abstract objects containing information on the operation to be performed for an app component.
+
+After disassembling the class.dex to generate the smalis files, Dalvik bytecode (example: invoke-direct) is gained through scanning the method field in smalis files with regular expression. Opcode are obtained by mapping the Dalvik bytecode to a series of letters as described in Table 2.
+
+Opcode features are segmented by N-gram to obtain the transformation sequence. The dimensionality reduction approach is employed to address the problem of the high dimensionality of the feature vector due to the increase of the number of N-grams with the value of N. Firstly, the N-gram set of malicious samples is extracted by the N-gram extraction process proposed in [47]. The top k high-frequency N-grams are selected, presented as  $Set = \{x_1, x_2, x_3, \dots, x_k\}$ . Subsequently, a k-dimensional binary feature vector  $f_{\text{feature}} = [m_1, m_2, m_3, \dots, m_k]$  is constructed for the sample based on this feature set, where  $m_i$  is "1" indicates that the N-gram set of the sample contains the element  $x_i$  in the feature
+
+set.
+
+From the above discussion, the whole process to detect Android malware using DroidRL for feature selection is depicted in Figure 3. Android application samples are collected from Drebin and Androzoo datasets, decompiled by Android reverse engineering tools to extract the permissions, intent actions, and N-grams as the original features. Then DroidRL feature selection is applied to select the valid feature subsets from the original features. The valid feature subset is saved and employed to validate the performance of the malware classifier, using the number of features and accuracy as evaluating index. 10-fold cross-validation is used in the experiment to evaluate the models and avoid overfitting. The features selected by DroidRL will be used to train a final classifier for malware detection.
+
+# 5.3. Hyperparameters setting
+
+The detailed description and setting of DroidRL's parameters are shown in Table 8. The classifiers in DroidRL are built with scikit-learn and all hyperparameters used are set by default.
+
+# 6. EXPERIMENT RESULTS
+
+The following research questions have been brought out to help follow the process of experiment conduction:
+
+RQ1 Is the result produced by the DroidRL framework stable selecting only a dozen features from a high-dimensional exploration space (e.g. 1083, the dimensionality of the original feature vector)?
+
+RQ2 Does the decision network learn the key information conducive to the next optimal feature selection in the process of training?
+
+RQ3 What is the performance of different classifiers using the optimal feature subset selected by the DroidRL framework as input?
+
+RQ4 What is the impact on the training time of malware classifiers of using the feature subset selected by DroidRL rather than the original features?
+
+RQ5 How is the performance of the DroidRL framework compared with other advanced methods in related work?
+
+# 6.1. Stability Evaluation of Feature Selection Results
+
+The key to adopting reinforcement learning to explore the best subset of features for Android malware detection is to find the best combination of features. However, with the exploration-exploitation strategy, DroidRL could take different actions even in the same state. There are inevitable differences in the optimal feature subset selected by the DroidRL. Moreover, the space that can be explored by reinforcement learning is gigantic. Only about 24 of the total set of 1083 features in the experiment are selected as input for malware detection. The different results may also cause the instability of the experiment results.
+
+In an attempt to verify whether the randomness brought by the exploration-exploitation strategy will affect the final detection accuracy, and to further prove the stability of the feature selection result of DroidRL, this experiment uses decision tree (DT) as the classifier and tested the accuracy using five different feature subsets results obtained from DroidRL as input. The result is illustrated in Figure 4
+
+Although the final results of the features selected by reinforcement learning in the five experiments are not strictly identical, it can be seen from Figure 4 that the detection accuracy always lies in the  $92\% - 95\%$  range with few points appearing deviation due to the randomness brought by the exploration-exploitation strategy. Though the action taken by the agent each time can not be exactly the same when exploring the inexhaustible combination of feature subsets, the detection accuracy of using the selected features for malware classification generally remains stable.
+
+# 6.2. Evaluation of the Learning Procedure of DroidRL
+
+To illustrate the learning procedure of the decision network in the DroidRL framework, the reward, the training classification accuracy (Train Acc in Figure 5), and the testing classification accuracy (Test Acc in Figure 5) in each training episode were tracked. The accuracy in one episode (e.a., training evaluation episode or testing evaluation episode) is gained from the classifier using the selected features as input. In the training episode, the agent select features using exploration-exploitation strategy and the decision network is in the training mode; Train Acc is the malware classification accuracy by running one training evaluation episode on the training dataset. In the testing evaluation episode, the feature selection process of the agent is only guided by the decision network without random exploration; Test Acc is the average of the accuracy in the five testing evaluation episodes.
+
+After each training episode, the DroidRL framework was tested by running five testing evaluation episodes in Figure 5 (a). In addition, taking 50 training episodes as a period, the DroidRL framework was tested after every period
+
+![](images/9fafbcfb4f7ea57151cc0fc91378784e94ec3a41caea3b43547c74d0b988a7c0.jpg)  
+Figure 4: Stability verification of different feature selection results by DroidRL
+
+in Figure 5 (b) with the same approach to calculate the testing classification accuracy. Moreover, the training accuracy of one period was recorded as the average malware classification accuracy of the 50 training episodes.
+
+In this experiment, the Long Short-Term Memory (LSTM) [13] severs as DroidRL's decision network since it has better contextual memory than RNN. The Decision Tree (DT) is applied as the classifier Similar tendencies are observed both in Figure 5 (a) and Figure 5 (b), as both results display the increasing reward and the malware classification accuracy. However, significant differences can be witnessed in the two figures, the training classification accuracy fluctuate greatly in Figure 5 (a), but remains comparatively low before 20 periods (e.g., 1000 episodes) and then rises to a higher stable state after in Figure 5 (b). Also, the testing classification accuracy is always slightly higher than the training classification accuracy. The above experimental results can be explained as follows:
+
+(1) Both figures indicate the increasing reward and malware classification accuracy, showing learning performance of the DroidRL framework.  
+(2) In the training episodes of the DroidRL,  $\epsilon$ -Greedy algorithm was used to balance between exploitation and exploration, but it was inevitable to select some redundant or irrelevant features in the exploration process. As shown in 5 (a), the fluctuated training accuracy is always higher than the testing accuracy. After about 20 periods, The testing accuracy becomes stable through utilizing existing experience while the training accuracy still has some sudden drops caused by  $\epsilon$ -Greedy algorithm.  
+(3) After using the average accuracy of 50 episodes, the training classification accuracy in Figure 5 (b) is more stable in the first 20 periods compared with Figure 5 (a), which clearly shows its changing trend. Due to the gradually decreasing exploration probability of  $\epsilon$ -Greedy algorithm in the later stage, the agent tended to use the existing experience from the decision network for feature selection. It led to higher and more stable training classification accuracy, as well as an accuracy curve more similar to the testing phase in the later periods, as shown in Figure 5 (b).
+
+# 6.3. Comparison with Different Decision Networks
+
+It is common practice to clarify the decision network selection criteria for a reinforcement learning based algorithm. Therefore, experiments on comparison with different decision networks are conducted and the results are described detailed in this section.
+
+Effective for processing data with sequence characteristics, RNN and its variants have the capability to exploit the temporal and semantic information in the input data and are universally applied to predict the following content according to the context in natural language processing. Therefore, the DroidRL framework adopted an RNN-like network as the decision network to predict the feature to be selected in the next step according to the Android features selected in the previous steps.
+
+![](images/b90fe2f19f9edfdc623b1a0d98b0e1b4c8355dfbe5856ec3ed5fc2a9af38d447.jpg)  
+(a) Test the DroidRL model after each training episode
+
+![](images/3d266feb077d252e4b4ace04e4b6fd5cb2f15c48f7764055ad012cd5dfc47597.jpg)  
+(b) Test the DroidRL model after every 50 training episode
+
+![](images/aa97da4e3728a9b0bc53f87ce90c15c9b018114765e8bd8f51285a0548fb4770.jpg)  
+Figure 5: The evaluation of the performance of the DroidRL framework during training  
+Figure 6: The evaluation of different decision networks
+
+With an attempt to explore which was the most suitable recurrent neural network as the decision network of DroidRL, this experiment applied RNN, Long Short-Term Memory (LSTM) [13] or Gated Recurrent Unit (GRU) [9] as the decision network for training respectively.
+
+In the experiment, 10-fold cross-validation is employed on the shuffled dataset. The average accuracy on the testing set was taken as the classification accuracy. The results are presented in Figure 6.
+
+As the experimental results figures sketch, with more selected Android features in the final valid feature subset, steadily increased higher accuracy is witnessed in RNN, GRU, and SLTM. The accuracy fluctuation was the most stable when using GRU as the decision network. The model obtained the best performance (eg.  $95.6\%$  accuracy) with 24 features selected in LSTM as input for malware classification, and the computational overhead was reduced by  $97.78\%$ .
+
+Based on the above experimental results, the following explanations are concluded according to the principle of the DroidRL framework. Reinforcement learning has a significant effect on selecting the optimal Android feature subset. Adopting the traditional LSTM as the decision network, DroidRL reduced the computational overhead by  $97.78\%$  and retains the accuracy of  $95.6\%$ .
+
+# 6.4. Comparison with Different Classifiers
+
+To demonstrate the performance of our model, we conducted a series of comparative experiments to find the combination of different quantities of features and different classifiers. As shown in Figure 7, the vertical axis represents the max number of features selected by reinforcement learning-based algorithm for malware detection. More precisely, to make the learning procedure efficient and meaningful, the number of features selected by the model is limited from 6 to 24.
+
+It can be seen in Figure 7, when the number of selected features is relatively small, the accuracy is about  $90\%$ . As the number of selected features increases, the accuracy gradually improves, raising to  $95\%$ .
+
+Figure 7 shows that reinforcement learning can be applied to Android malware detection to select valid feature sets for malware classification. The accuracy is stable on Random Forest (RF), Decision Tree (DT), and Support Vector Machine (SVM). It can be observed in the Table 6 and Table 7 that DT, RF, and SVM achieve higher accuracy with fewer features and have a stable performance. K-Nearest Neighbors (KNN) models perform not so well, as seen from the fluctuation of the accuracy in figures. After the verification experiment, it is found that different hyperparameters k are suitable for classifying different feature numbers, so the accuracy fluctuates greatly with the number of selected features.
+
+# 6.5. Comparison of the Classifiers' Training Time
+
+The computational complexity of machine learning algorithms grows with the number of samples and features. While the increase in sample size can bring more robustness to the classifier, the increasing number of features could bring redundancy. A large number of features also increase the computational complexity and resources required for training. To evaluate the ability of DroidRL to retain training efficiency, this experiment uses feature subsets with different lengths selected by DroidRL to train various malware classifiers. To measure the improvement in training efficiency, we calculated the ratio of the time consumed to train the classifier using a subset of features to the time spent using the full feature set.
+
+As shown in Table 3, using the subsets to train the models significantly improves the training efficiency. The reason for the relatively large ratio on Random Forest mainly lies in that there are many subtrees in the model. There is a lower bound on the time to train subtrees as the number of features decreases.
+
+Another noteworthy phenomenon is that the training time ratio does not strictly improve with the number of features, and sometimes even drops. This indicates that DroidRL filters out features that are useful for classification, and the added features allow the classifiers to easier find decision boundaries, which in turn speeds up training.
+
+# 6.6. Comparison with Related Work
+
+To make a comprehensive comparison between the proposed DroidRL framework and related Android malware detection methods, we conduct a comparative experiment based on the dataset in our work. The implementation of detection methods in this section refers to the code of the work [27].
+
+Firstly, to illustrate the effect of feature selection in machine learning based Android malware detection, we compare DroidRL with other Android malware detection approaches without applying the feature selection method. The results are displayed in Table 4. The proposed DroidRL framework outperforms DroidDet [48], HMMDetector [8], and
+
+![](images/f72582272158d3d5fe1cd4b01da2e3cfde8c3486a0ed87bb88ce052edc8fd575.jpg)  
+DroidRL  
+(a) DT as classifier
+
+![](images/1d7b4d946c2e310332021513b995cd77be65443588c74a75c7d8f25f6a65c338.jpg)  
+(b) RF as classifier
+
+![](images/e19adea091c363813107fd467f041b8d8f0f3f02f508d924eb4b8ff46f9b890d.jpg)  
+(c) SVM as classifier
+
+![](images/8cb9c82fd10ebc689b4a384b3a2748f93a82d23a66295a316d2dbb1e41b13abd.jpg)  
+(d) KNN as classifier  
+Figure 7: The performance on different classifiers
+
+Table 3 Training time ratio  
+
+<table><tr><td>Ratio(%)1 Features Used 
+Classifier</td><td>16</td><td>17</td><td>18</td><td>19</td><td>20</td><td>21</td><td>22</td><td>23</td><td>24</td></tr><tr><td>Decision Tree</td><td>1.23</td><td>1.64</td><td>1.36</td><td>1.78</td><td>1.63</td><td>1.62</td><td>1.91</td><td>2.06</td><td>2.78</td></tr><tr><td>Random Forest</td><td>15.07</td><td>16.64</td><td>15.66</td><td>17.35</td><td>16.64</td><td>16.36</td><td>16.34</td><td>16.85</td><td>17.81</td></tr><tr><td>Support Vector Machine</td><td>3.53</td><td>4.22</td><td>4.13</td><td>4.50</td><td>4.51</td><td>4.49</td><td>4.79</td><td>4.74</td><td>4.88</td></tr></table>
+
+1 The Ratio represents the percentage of time consumed for training with a subset of features versus training with all(1083) features
+
+Table 4 Comparison with detection approaches without feature selection  
+
+<table><tr><td>Method</td><td>Number of Features</td><td>Accuracy</td><td>ML Based Detection Model</td></tr><tr><td>MamaDroid[30]</td><td>190,096</td><td>0.989</td><td>Random Forest</td></tr><tr><td>DroidDet[48]</td><td>3,122</td><td>0.921</td><td>Rotation Forest</td></tr><tr><td>HMMDetector[8]</td><td>-</td><td>0.871</td><td>Hidden Markov Model, Random Forest</td></tr><tr><td>Drebin[3]</td><td>545,356</td><td>0.881</td><td>Support Vector Machine</td></tr><tr><td>DroidRL (ours)</td><td>24</td><td>0.956</td><td>Random Forest</td></tr></table>
+
+Table 5 Comparison with different feature selection approaches  
+
+<table><tr><td>Method</td><td>Number of Features</td><td>Accuracy</td><td>Feature Selection Method</td><td>ML Based Detection Model</td></tr><tr><td>ICCDetector [43]</td><td>40</td><td>0.948</td><td>Correlation-based Feature Selection</td><td>Support Vector Machine</td></tr><tr><td>BasicBlocks [1]</td><td>45</td><td>0.947</td><td>Information Gain</td><td>Random Forest</td></tr><tr><td>DroidRL (ours)</td><td>24</td><td>0.956</td><td>Reinforcement Learning</td><td>Random Forest</td></tr></table>
+
+Drebin [3] with higher accuracy and fewer features used in the detection, which demonstrates the features selected by reinforcement learning are highly relevant to the malware attributes. With 190,072 more features extracted compared to DroidRL, MamaDroid [30] only obtains a 0.033 higher accuracy, increasing accuracy at the huge running cost. It is highly time-consuming to extract 190,096 features and detect malware with so many features. Android malware detection is much more computationally efficient with valid feature subsets containing only 24 features selected by reinforcement learning used in our model.
+
+To further demonstrate the optimality of the features selected by DroidRL, the performance of DroidRL is compared with other feature selection methods used for machine learning based Android malware detection. The results of these experiments are shown in Table 5 with the number of features and detection performance accuracy as indicators. We implemented these methods with a specified number of features used in detection as shown in the table (not necessarily the same number in the original work). Compared with other traditional feature selection methods listed in the table, DroidRL obtains higher accuracy with a smaller number of features used in the detection, displaying that reinforcement learning retains its power to filter optimal features. Because, as the wrapper-based feature selection method that can utilize the feedback from the classifier to evaluate the feature subset, DroidRL can select an optimal subset of features.
+
+# 7. CONCLUSION
+
+The proposed DroidRL applies the DDQN algorithm to the feature selection phase to select the optimal subset of features for Android malware detection. Especially, the RNN-like network is applied as the decision network in DDQN for its capability of processing variable-length sequences. For the purpose of finding the correlation between features, DroidRL uses word embedding to semantically represent the features. During the training phase, the train-off policy is used to increase the feature search space of the DroidRL. Experiments on Drebin and Androzoo demonstrate that the DroidRL framework shows better performance than the traditional static feature extraction models, markedly
+
+Table 6 Detailed performance of each classifier(1)  
+
+<table><tr><td>Classifier\Features Used</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td><td>11</td><td>12</td><td>13</td><td>14</td></tr><tr><td>Decision Tree</td><td>0.929</td><td>0.927</td><td>0.932</td><td>0.943</td><td>0.938</td><td>0.935</td><td>0.932</td><td>0.938</td><td>0.942</td></tr><tr><td>Random Forest</td><td>0.929</td><td>0.927</td><td>0.933</td><td>0.942</td><td>0.940</td><td>0.936</td><td>0.932</td><td>0.940</td><td>0.942</td></tr><tr><td>KNN</td><td>0.911</td><td>0.732</td><td>0.811</td><td>0.891</td><td>0.810</td><td>0.660</td><td>0.920</td><td>0.860</td><td>0.820</td></tr><tr><td>SVM</td><td>0.928</td><td>0.927</td><td>0.930</td><td>0.941</td><td>0.935</td><td>0.936</td><td>0.932</td><td>0.940</td><td>0.938</td></tr></table>
+
+Table 7 Detailed performance of each classifier(2)  
+
+<table><tr><td>Classifier\Features Used</td><td>15</td><td>16</td><td>17</td><td>18</td><td>19</td><td>20</td><td>21</td><td>22</td><td>23</td><td>24</td></tr><tr><td>Decision Tree</td><td>0.936</td><td>0.941</td><td>0.946</td><td>0.944</td><td>0.945</td><td>0.943</td><td>0.940</td><td>0.950</td><td>0.948</td><td>0.955</td></tr><tr><td>Random Forest</td><td>0.936</td><td>0.942</td><td>0.948</td><td>0.944</td><td>0.946</td><td>0.943</td><td>0.939</td><td>0.952</td><td>0.948</td><td>0.956</td></tr><tr><td>KNN</td><td>0.793</td><td>0.940</td><td>0.934</td><td>0.940</td><td>0.936</td><td>0.936</td><td>0.937</td><td>0.938</td><td>0.945</td><td>0.945</td></tr><tr><td>SVM</td><td>0.936</td><td>0.939</td><td>0.941</td><td>0.939</td><td>0.942</td><td>0.941</td><td>0.938</td><td>0.943</td><td>0.945</td><td>0.951</td></tr></table>
+
+Table 8 Hyperparameter setting  
+
+<table><tr><td>Parameter</td><td>Value</td><td>Description</td></tr><tr><td>replay start size</td><td>50,000</td><td>The number of steps carried out by the agency using uniform random policy</td></tr><tr><td>replay buffer size</td><td>200,000</td><td>The capacity of replay buffer memory</td></tr><tr><td>batch size</td><td>32</td><td>The number of training cases over which each gradient descent update is computed</td></tr><tr><td>discount factor</td><td>0.99</td><td>The factor that determines the importance of future rewards in the Q-learning</td></tr><tr><td>start learning rate</td><td>0.0003</td><td>The start factor of the linear decay scheduler</td></tr><tr><td>training interval</td><td>5</td><td>The frequency that the decision network is trained</td></tr></table>
+
+improving detection performance on a variety of classifiers. The DroidRL is shown to be effective on feature selection tasks and it will hopefully serve as an element to build up a robust malware detector in the future.
+
+# References
+
+[1] Allix, K., Bissyandé, T.F., Jérôme, Q., Klein, J., State, R., Le Traon, Y., 2016a. Empirical assessment of machine learning-based malware detectors for android. Empirical Softw. Engg. 21, 183-211. URL: https://doi.org/10.1007/s10664-014-9352-6, doi:10.1007/s10664-014-9352-6.  
+[2] Allix, K., Bissyandé, T.F., Klein, J., Le Traon, Y., 2016b. Androzoo: Collecting millions of android apps for the research community, in: Proceedings of the 13th International Conference on Mining Software Repositories, ACM, New York, NY, USA. pp. 468-471. URL: http://doi.acm.org/10.1145/2901739.2903508, doi:10.1145/2901739.2903508.  
+[3] Arp, D., Spreitzenbarth, M., Hübner, M., Gascon, H., Rieck, K., 2014a. Drebin: Effective and explainable detection of android malware in your pocket doi:10.14722/ndss.2014.23247.  
+[4] Arp, D., Spreitzenbarth, M., Hubner, M., Gascon, H., Rieck, K., Siemens, C., 2014b. Drebin: Effective and explainable detection of android malware in your pocket., in: Ndss, pp. 23-26.  
+[5] Babaagba, K.O., Adesanya, S.O., 2019. A study on the effect of feature selection on malware analysis using machine learning. ACM International Conference Proceeding Series Part F148151, 51-55. doi:10.1145/3318396.3318448.  
+[6] Bibi, I., Akhunzada, A., Malik, J., Iqbal, J., Mussaddiq, A., Kim, S., 2020. A dynamic dl-driven architecture to combat sophisticated android malware. IEEE Access 8, 129600-129612.  
+[7] Binxiang, L., Gang, Z., Ruoying, S., 2019. A Deep Reinforcement Learning Malware Detection Method Based on PE Feature Distribution, 23-27doi:10.1109/ICISCE48695.2019.00014.  
+[8] Canfora, G., Mercaldo, F., Visaggio, C.A., 2016. An hmm and structural entropy based detector for android malware: An empirical study. Computers & Security 61, 1-18. URL: https://www.sciencedirect.com/science/article/pii/S0167404816300499, doi:https://doi.org/10.1016/j.cose.2016.04.009.
+
+[9] Cho, K., Van Merrienboer, B., Gulcehre, C., Bahdanau, D., Bougaes, F., Schwenk, H., Bengio, Y., 2014. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078.  
+[10] Dash, M., Liu, H., 2003. Consistency-based search in feature selection. Artificial Intelligence 151, 155-176.  
+[11] Fang, Z., Wang, J., Geng, J., Kan, X., 2019. Feature Selection for Malware Detection Based on Reinforcement Learning. IEEE Access 7, 176177-176187. doi:10.1109/ACCESS.2019.2957429.  
+[12] Fatima, A., Maurya, R., Dutta, M.K., Burget, R., Masek, J., 2019. Android malware detection using genetic algorithm based optimized feature selection and machine learning. 2019 42nd International Conference on Telecommunications and Signal Processing, TSP 2019, 220-223doi:10.1109/TSP.2019.8769039.  
+[13] Graves, A., 2012. Long short-term memory. Springer Berlin Heidelberg.  
+[14] Hall, M.A., 2000. Correlation-based feature selection for machine learning. Morgan Kaufmann Publishers Inc..  
+[15] Hasselt, H.V.A.N., Guez, A., Silver, D., Deepmind, G., 2015. Deep reinforcement learning with double q-learning arXiv:arXiv:1509.06461v1.  
+[16] Huang, J.J., Cai, Y.Z., Xu, X.M., 2008. A parameterless feature ranking algorithm based on MI. Neurocomputing 71, 1656-1668. doi:10.1016/j.neucom.2007.04.012.  
+[17] Huda, S., Abawajy, J., Alazab, M., Abdollahihian, M., Islam, R., Yearwood, J., 2016. Hybrids of support vector machine wrapper and filter based framework for malware detection. Future Generation Computer Systems 55, 376-390. URL: https://www.sciencedirect.com/science/article/pii/S0167739X14001228, doi:https://doi.org/10.1016/j_future.2014.06.001.  
+[18] Ji-Xiang, Y.E., Gong, X.L., 2010. A novel fast wrapper for feature subset selection. Journal of Changsha University of Science & Technology(Natural Science).  
+[19] Kouliaridis, V., Barmpatsalou, K., Kambourakis, G., Chen, S., 2020. A survey on mobile malware detection techniques. IEICE Transactions on Information and Systems 103, 204-211.  
+[20] Lei, Y., Huan, L., 2003. Feature selection for high-dimensional data: A fast correlation-based filter solution, in: Proceedings of the Twentieth International Conference on International Conference on Machine Learning, AAAI Press. p. 856-863.  
+[21] Mahindru, A., Sangal, A.L., 2020. SOMDROID: android malware detection by artificial neural network trained using unsupervised learning. Springer Berlin Heidelberg. URL: https://doi.org/10.1007/s12065-020-00518-1, doi:10.1007/s12065-020-00518-1.  
+[22] Mahindru, A., Sangal, A.L., 2021. FSDroid: - A feature selection technique to detect malware from Android using Machine Learning Techniques: FSDroid. Multimedia Tools and Applications doi:10.1007/s11042-020-10367-w.  
+[23] Mantoo, B.A., 2020. A hybrid approach with intrinsic feature-based android malware detection using lda and machine learning, in: The International Conference on Recent Innovations in Computing, Springer. pp. 295-306.  
+[24] Mcwilliams, G., Sezer, S., Yerima, S.Y., 2014. Analysis of bayesian classification-based approaches for android malware detection. Information Security Let 8, 25-36.  
+[25] Melo, F.S., 2001. Convergence of Q-learning: A simple proof. Institute Of Systems and Robotics, Tech. Rep , 1-4arXiv:arXiv:1011.1669v3.  
+[26] Mnih, V., Kavukcuoglu, K., Silver, D., Rusu, A.A., Veness, J., Bellemare, M.G., Graves, A., Riedmiller, M., Fidjeland, A.K., Ostrovski, G., Petersen, S., Beattie, C., Sadik, A., Antonoglou, I., King, H., Kumaran, D., Wierstra, D., Legg, S., Hassabis, D., 2015. Human-level control through deep reinforcement learning. Nature 518, 529-533. URL: http://dx.doi.org/10.1038/nature14236, doi:10.1038/nature14236.  
+[27] Molina-Coronado, B., Mori, U., Mendiburu, A., Miguel-Alonso, J., 2023. Towards a fair comparison and realistic evaluation framework of android malware detectors based on static analysis and machine learning. Computers & Security 124, 102996. URL: https://www.sciencedirect.com/science/article/pii/S0167404822003881, doi:https://doi.org/10.1016/j.cose.2022.102996.  
+[28] Narayanan, A., Chandramohan, M., Chen, L., Liu, Y., 2017. Context-aware, adaptive, and scalable android malware detection through online learning. IEEE Transactions on Emerging Topics in Computational Intelligence 1, 157-175.  
+[29] O Yildiz, D., Alper, I., 2019. Permission-based android malware detection system using feature selection with genetic algorithm. International Journal of Software Engineering and Knowledge Engineering 29, 245-262. doi:10.1142/S0218194019500116.  
+[30] Onwuzurike, L., Mariconti, E., Andriotis, P., Cristofaro, E.D., Ross, G., Stringhini, G., 2019. Mamadroid: Detecting android malware by building markov chains of behavioral models (extended version). ACM Trans. Priv. Secur. 22. URL: https://doi.org/10.1145/3313391, doi:10.1145/3313391.  
+[31] Papamartzivanos, D., Damopoulos, D., Kambourakis, G., 2014. A cloud-based architecture to crowdsourced mobile app privacy leaks, in: Proceedings of the 18th panhellenic conference on informatics, pp. 1-6.  
+[32] Priya, V.D., P., V., 2020. Detecting android malware using an improved filter based technique in embedded software. Microprocessors and Microsystems 76.  
+[33] security team of Qianxin Threat Intelligence Center, M., 2020. Security situation analysis report of android platform in 2020. URL: https://www.qianxin.com/threat/reportdetail?report_id=125.  
+[34] Rathore, H., Sahay, S.K., Nikam, P., Sewak, M., 2020. Robust Android Malware Detection System Against Adversarial Attacks Using Q-Learning. Information Systems Frontiers doi:10.1007/s10796-020-10083-8.  
+[35] S., Y.E., 2002. Feature selection in support vector machines. University of Florida 7, 1-28.  
+[36] Salah, A., Shalabi, E., Khedr, W., 2020. A lightweight android malware classifier using novel feature selection methods. Symmetry 12, 858.  
+[37] Spolar, N., Cherman, E.A., Monard, M.C., Lee, H.D., 2013. Relief for multi-label feature selection, in: Proceedings of the 2013 Brazilian Conference on Intelligent Systems.  
+[38] Team, M.D.R., 2021. Cyberbattlesim. URL: https://github.com/microsoft/cyberbattlesim. created by Christian Seifert, Michael Betser, William Blum, James Bono, Kate Farris, Emily Goren, Justin Grana, Kristian Holsheimer, Brandon Marken, Joshua Neil, Nicole Nichols, Jugal Parikh, Haoran Wei.  
+[39] Wan, X., Sheng, G., Li, Y., Xiao, L., Du, X., 2017. Reinforcement Learning Based Mobile Offloading for Cloud-based Malware Detection.
+
+[40] Wang, S., Chen, Z., Yan, Q., Ji, K., Peng, L., Yang, B., 2020. Deep and broad URL feature mining for android malware detection 513, 600-613. doi:10.1016/j.ins.2019.11.008.  
+[41] Wang, W., Wang, X., Feng, D., Liu, J., Han, Z., Zhang, X., 2014. Exploring permission-induced risk in android applications for malicious application detection. IEEE Transactions on Information Forensics and Security 9, 1869-1882. doi:10.1109/TIFS.2014.2353996.  
+[42] Witten, I.H., Frank, E., 2011. Data mining: practical machine learning tools and techniques. Acm Sigmoid Record 31, 76-77.  
+[43] Xu, K., Li, Y., Deng, R.H., 2016. Iccdetector: Icc-based malware detection on android. IEEE Transactions on Information Forensics and Security 11, 1252-1264. doi:10.1109/TIFS.2016.2523912.  
+[44] Yan, P., Yan, Z., 2018. A survey on dynamic mobile malware detection. Software Quality Journal 26, 891-919.  
+[45] Yuan, Z., Lu, Y., Xue, Y., 2016. Droid detector: Android malware characterization and detection using deep learning. Tsinghua Sci. Technol.  
+[46] Zhang, N., Tan, Y.a., Yang, C., Li, Y., 2021. Deep learning feature exploration for android malware detection. Applied Soft Computing 102, 107069.  
+[47] ZHANG Zong-mei, GUI Sheng-lin, R.F., 2019. Android malware detection based on n-gram. COMPUTER SCIENCE v.46, 154–160.  
+[48] Zhu, H.J., You, Z.H., Zhu, Z.X., Shi, W.L., Chen, X., Cheng, L., 2018. Droiddet: Effective and robust detection of android malware using static analysis along with rotation forest model. Neurocomputing 272, 638-646. URL: https://www.sciencedirect.com/science/article/pii/S0925231217312870, doi:https://doi.org/10.1016/j.neucom.2017.07.030.
+
+# DroidRL
+
+![](images/895fa5e438989f4a97e48132a9d80ff7dfa7a845075a7e61f73b308fda9d729b.jpg)
+
+Yinwei Wu studies in Software College of Sichuan University, Chengdu, China. He is now involved in research work on information security. His research interests include software security, deep learning and reinforcement learning.
+
+![](images/c5563a977dfd7086c4c044339fe2acf0140eb62699052f12af552d7a4ecf969a.jpg)
+
+Meijin Li is from Sichuan University, Chengdu, China. She is currently engaged in research in the field of network security and is interested in machine learning and mobile security.
+
+![](images/55e6d54f464e24359d957ca51fc03970879b4840c69c9015433d8f9eba15aab4.jpg)
+
+Zeng Qi is expected to receive a bachelor's degree in Computer Science and Technology from Sichuan University, Chengdu in 2023. His research interests include machine learning and software security
+
+# DroidRL
+
+![](images/3bcdda24009ed06e87786717c8202e967f5e26a2e894692ff7a310bc62e032cb.jpg)
+
+![](images/2d3548fb2f25a92a03afcdb09a0318c1e94698c0ddd659701da10fdd11bbb989.jpg)
+
+Tao Yang is currently pursuing a bachelor's degree in Computer Science and Technology from Sichuan University, Chengdu in 2022. He is recently involved in research work on information security. His research interests include android malware detection and machine learning.
+
+Junfeng Wang received the M.S. degree in Computer Application Technology from Chongqing University of Posts and Telecommunications, Chongqing in 2001 and Ph.D. degree in Computer Science from University of Electronic Science and Technology of China, Chengdu in 2004. From July 2004 to August 2006, he held a postdoctoral position in Institute of Software, Chinese Academy of Sciences. From August 2006, Dr. Wang is with the College of Computer Science and the School of Aeronautics & Astronautics, Sichuan University as a professor. He is currently serving as an associate editor for IEEE Access, IEEE Internet of Things and Security and Communication Networks, etc. His recent research interests include network and information security, spatial information networks and data mining.
+
+![](images/f3bbdd111cdc29cae8eedef4424eed3814aec0d28cf3cf2857de0d82789cadfb.jpg)
+
+Zhiyang Fang received his Ph.D. degree in Computer Science and Technology from Sichuan University, Chengdu in 2020. He is currently involved in research work on information security. His research interests include software security, deep learning and software engineering.
+
+![](images/329038a50b78b68fd8a9a12c3f37c39f2f58c552181d61b661344e1c89270e93.jpg)
+
+Luyu Cheng studies in Business School from Sichuan University, Chengdu, China. Her research interests include supply chain management, data analysis, etc.

2203.02xxx/2203.02719/images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e748ef41562599bb2c27fe4dcf7a34ec61949572efdd281c6cacffb25addf83a
+size 732497