KR102488409B1 - Repair method and apparatus for automatic bug localization using deep learning algorithm - Google Patents

Abstract

The bug correction device detects a buggy line where a bug exists from verification information about the source code and the program based on an input unit for receiving the source code of the program, an autoencoder, and a Convolution Neural Network (CNN). and a bug location identification unit for identifying a location and a bug correction unit for generating a correction code in which the bug is corrected by inputting the code of the buggy line into a correction model based on a sequence adversarial network.

Description

Correction method and apparatus through automatic bug location identification using deep learning algorithm {REPAIR METHOD AND APPARATUS FOR AUTOMATIC BUG LOCALIZATION USING DEEP LEARNING ALGORITHM}

The present invention relates to a correction method and apparatus through automatic bug location identification using a deep learning algorithm.

If there is an erroneous code in the contents of the program, the cause of the error or malfunction of the program by such a defect is called a bug. As the size and complexity of software increases, bugs large and small inevitably occur.

On average, about 350 bug reports are submitted per day in open source projects such as Eclipse and Mozilla, and developers spend most of their time debugging in the process of maintaining and repairing software. there is.

Accordingly, there is a problem in that a lot of time and money are continuously required for maintenance and repair of the software. To solve this problem, research on technology for automating bug correction is being conducted. For example, there are ways to automate bug fixes based on genetic programming.

In addition, the conventional method of identifying a bug location has expanded the information of the bug report with an attachment of the bug report and an extended query. However, there is a limitation that the performance of identifying bug locations is not improved even if the training data is expanded.

On the other hand, a generative adversarial network (GAN) develops through an adversarial process in which a generative model and an identification model compete with each other. Adversarial generative networks are mainly used to generate outputs very similar to real examples.

Korean Patent Publication No. 10-2019-0089615 (published on July 31, 2019)

The present invention is to solve the problems of the prior art described above, receives an error source code of a program, and identifies a source code file based on an auto encoder and a CNN. And a method for identifying the location of a buggy line from verification information about a program for the same input and inputting the code of the buggy line into a sequence adversarial generation network-based correction model to generate a corrected code in which the bug is corrected. want to provide

By training the auto-encoder and correction model, we intend to provide a method in which the accuracy of bug location identification and the performance of bug correction are gradually improved.

However, the technical problem to be achieved by the present embodiment is not limited to the technical problems described above, and other technical problems may exist.

As a means for achieving the above-described technical problem, an embodiment of the present invention is a bug correction device based on an input unit for receiving a program source code, an autoencoder, and a convolution neural network (CNN). A bug location identification unit that identifies the location of a buggy line where a bug exists from the source code and verification information about the program, and the code of the buggy line is converted to a correction model based on a sequence adversarial generation network (Seq-GAN) It may include a bug correction unit that generates a correction code in which the bug is corrected by inputting the code.

In one embodiment, it may further include a conversion unit that converts the program based on the corrected code and a test unit that performs a conformance test on the source code of the converted program.

In one embodiment, the verification information may include a bug report and a stack trace for the program.

In one embodiment, the bug location identification unit extracts one or more features from the source code and the verification information, inputs the extracted one or more features to an encoder of an auto encoder, and converts the latent vector output from the encoder into the CNN. It is possible to identify the position of the buggy line from the output of the CNN by inputting to .

In one embodiment, the correction model may include an RNN-based generative model for generating source code and a CNN-based identification model for identifying whether or not the source code generated by the generative model is normal.

In one embodiment, a learning unit for learning the correction model is further included, wherein the learning unit generates a normal or abnormal source code for the RNN-based generation model and the normal or abnormal source code for the CNN-based identification model. The identification model may be trained to identify whether a code is normal, and the auto-encoder may be trained to have the same input value and output value of the auto-encoder.

In one embodiment, the bug correction unit may generate a common word dictionary and a user word dictionary based on the source code of the program.

In an embodiment, the conversion unit may apply the correction code to the buggy line and convert the program using a variable name recovery technique.

In one embodiment, the test unit performs the conformance test based on a plurality of test cases, and when the source code of the converted program passes all of the plurality of test cases, it may be determined that the bug correction is appropriate. .

In another embodiment of the present invention, in the bug correction method, the step of receiving the source code of a program, based on an autoencoder and CNN (Convolution Neural Network), a bug from the source code and verification information for the program Identifying the location of a buggy line where the buggy line exists and generating a correction code in which the bug is corrected by inputting the code of the buggy line into a correction model based on a sequence adversarial generation network (Seq-GAN). can include

The above-described means for solving the problems is only illustrative and should not be construed as limiting the present invention. In addition to the exemplary embodiments described above, there may be additional embodiments described in the drawings and detailed description.

According to any one of the above-described problem solving means of the present invention, the source code of the program is input, and the position of the buggy line is identified from the source code and verification information for the program based on the auto encoder and CNN, It is possible to provide a method of generating a corrected code in which a bug is corrected by inputting the code of the buggy line into a correction model based on a sequence adversarial generation network.

Also, as the learning data is expanded, the accuracy of the method of identifying the location of the buggy line using the auto-encoder may be improved.

In addition, it is possible to provide a bug correction method in which correction performance is gradually improved by applying a reinforcement learning policy to a correction model based on an adversarial generation network.

In addition, manpower and costs required for program debugging can be reduced by providing an automated bug correction method.

1 is a block diagram of a bug correction device according to an embodiment of the present invention.
2 is a diagram comparing results of a conventional bug location identification method and a bug location identification method according to an embodiment of the present invention.
3 is a diagram comparing results of a conventional bug correction method and a bug correction method according to an embodiment of the present invention.
4 is a flowchart of a bug correction method according to an embodiment of the present invention.

Hereinafter, embodiments of the present invention will be described in detail so that those skilled in the art can easily practice the present invention with reference to the accompanying drawings. However, the present invention may be embodied in many different forms and is not limited to the embodiments described herein. And in order to clearly explain the present invention in the drawings, parts irrelevant to the description are omitted, and similar reference numerals are attached to similar parts throughout the specification.

Throughout the specification, when a part is said to be "connected" to another part, this includes not only the case where it is "directly connected" but also the case where it is "electrically connected" with another element interposed therebetween. . In addition, when a part "includes" a certain component, this means that it may further include other components, not excluding other components, unless otherwise stated, and one or more other characteristics. However, it should be understood that it does not preclude the possibility of existence or addition of numbers, steps, operations, components, parts, or combinations thereof.

In this specification, a "unit" includes a unit realized by hardware, a unit realized by software, and a unit realized using both. Further, one unit may be realized using two or more hardware, and two or more units may be realized by one hardware. On the other hand, '~ unit' is not limited to software or hardware, and '~ unit' may be configured to be in an addressable storage medium or configured to reproduce one or more processors. Therefore, as an example, '~unit' refers to components such as software components, object-oriented software components, class components, and task components, processes, functions, properties, and procedures. , subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays and variables. Functions provided within components and '~units' may be combined into smaller numbers of components and '~units' or further separated into additional components and '~units'. In addition, components and '~units' may be implemented to play one or more CPUs in a device or a secure multimedia card.

The "network" referred to below refers to a connection structure capable of exchanging information between nodes such as terminals and servers, such as a local area network (LAN) and a wide area network (WAN). , the Internet (WWW: World Wide Web), wired and wireless data communications networks, telephone networks, and wired and wireless television communications networks. Examples of wireless data communication networks include 3G, 4G, 5G, 3rd Generation Partnership Project (3GPP), Long Term Evolution (LTE), World Interoperability for Microwave Access (WIMAX), Wi-Fi, Bluetooth communication, infrared communication, ultrasonic communication, visible light communication (VLC: Visible Light Communication), LiFi, and the like, but are not limited thereto.

In this specification, some of the operations or functions described as being performed by a terminal or device may be performed instead by a server connected to the terminal or device. Likewise, some of the operations or functions described as being performed by the server may also be performed in a terminal or device connected to the corresponding server.

Hereinafter, an embodiment of the present invention will be described in detail with reference to the accompanying drawings.

1 is a block diagram of a bug correction device according to an embodiment of the present invention. Referring to FIG. 1 , the bug correction device 100 includes an input unit 110, a bug location identification unit 120, a bug correction unit 130, a learning unit 140, a conversion unit 150, and a test unit 160. can include

The bug correction device 100 may correct a bug existing in the source code of a program. Errors or malfunctions of the program can be prevented by correcting the bug by the bug correction device 100.

For example, the bug correction device 100 first identifies the location of a buggy line in the source code (Bug Localization) and performs bug repair to remove the bug from the buggy line. can do.

The input unit 110 may receive a source code of a program. The source code of a program contains one or more lines, and each line may contain one or more words (tokens).

The bug location identification unit 120 may identify the location of the buggy line where the bug exists from the source code of the program and verification information about the program. Verification information about the program may include, for example, a bug report and a stack trace about the program.

The bug location identification unit 120 may extract one or more features from the source code of the program and verification information about the program.

For example, the bug location identification unit 120 may track a source code file similar to a bug report by using a Revised Vector Space Model (rVSM) technique. The bug location identification unit 120 may apply natural language processing technology and CamelCase to the bug report and source code files.

Natural language processing techniques may include, for example, tokenization of sentences, removal of stop words, or removal of special characters.

By applying CamelCase, complex characters can be separated. For example, a function name such as "CreatedQuery" can be separated into "Created" and "Query" by camel notation.

For example, the bug location identification unit 120 may analyze a correlation between a bug report and a stack trace through BRTracer.

The bug location identification unit 120 may identify the location of the buggy line based on an autoencoder and a convolution neural network (CNN).

The bug location identification unit 120 may output a latent vector by inputting one or more extracted features to an encoder of an auto encoder. The bug location identification unit 120 may input the latent vector output from the auto encoder to the CNN.

For example, the bug location identification unit 120 may output a rank score between a bug report and source code using CNN. The bug location identification unit 120 may identify the location of the buggy line based on the rank score output from the CNN.

2 is a diagram comparing results of a conventional bug location identification method and a bug location identification method according to an embodiment of the present invention.

Figure 2 (a) to (c), in the baseline including Tomcat, AspectJ, Birt, Eclipse, JDT and SWT, shows the accuracy of bug location identification as a graph. Figure 2(a) shows the average accuracy of bug location identification according to each method, Figure 2(b) shows the accuracy of MRR performance of each method, and Figure 2(c) shows the accuracy of each method Shows the accuracy of MAP performance.

Referring to (a) to (c) of FIG. 2 , it can be confirmed that the accuracy of identifying a bug location is improved by the method according to the present invention compared to the conventional bug location identification method.

The bug correction unit 130 may generate a common token dictionary and a user common token dictionary based on the source code of the program.

The bug correcting unit 130 may generate a common word dictionary and a user word dictionary by classifying each word included in the program source code into a common word or a user word.

The common word dictionary may include common words commonly used in the source code of the program. For example, the common word dictionary may include words related to types, keywords, semicolons (;), and library functions.

The user word dictionary may include user words, which are words used in the source code of a specific program. That is, the user word dictionary may include words other than common words among words included in the source code of the program.

For example, in the user word dictionary, user words may be stored in the order in which they appear in the program source code.

The bug correction unit 130 may generate a correction code in which a bug is corrected based on a correction model based on a sequence adversarial generation network (Seq-GAN). The correction model based on the sequence adversarial generation network may include a generation model and an identification model.

The generative model may be, for example, an RNN-based model that has been trained to generate source code. In the RNN-based generative model, a program sequence word (token) may be input and hidden unit activation may be updated.

Activation of the hidden unit (h _t ) can be expressed as Equation 1, for example. In Equation 1, x _t is an input of the RNN model, and t may be time.

The output (z(h _t )) of the RNN model can be expressed as Equation 2, for example. In Equation 2, b is a bias vector of the RNN, and W _vector may be a weight vector matrix.

The identification model may be, for example, a CNN-based model that identifies whether or not the source code generated by the generative model is normal.

As shown in FIG. 1 , the bug correction device 100 may further include a learning unit 140 . The learning unit 140 may train a correction model. The learning unit 140 may train a generation model and an identification model included in a correction model based on a reinforcement learning policy.

The learning unit 140 may train the RNN-based generation model to generate normal or abnormal source codes. The learning unit 140 may train a CNN-based identification model to identify normal or abnormal source codes generated by the generative model.

The learning unit 140 may train the auto encoder. For example, the learner 140 may train the auto-encoder so that an input value and an output value of the auto-encoder are the same.

For example, the bug correction unit 130 may generate a correction code by inputting a code of a buggy line into a correction model.

The conversion unit 150 may convert the program based on the correction code. For example, the conversion unit 150 may apply a correcting code to the buggy line and convert the program using a variable name recovery technique.

For example, the conversion unit 150 may convert a program by referring to a common word dictionary and a user word dictionary.

The test unit 160 may perform a conformance test on the source code of the converted program. The conformance test may be a test for determining whether a program to which a correction code is applied to a buggy line normally operates.

For example, the test unit 160 may perform a conformance test based on a plurality of test cases. The test unit 160 may determine that bug correction is appropriate when the source code of the converted program passes all of a plurality of test cases.

3 is a diagram comparing results of a conventional bug correction method and a bug correction method according to an embodiment of the present invention.

3 is a graph showing performance of bug correction by the conventional method and the method according to the present invention. Referring to FIG. 3 , it can be seen that performance of bug correction is improved by the method according to the present invention compared to DeepFix, which is a conventional bug correction method.

4 is a flowchart of a bug correction method according to an embodiment of the present invention. The method 400 for correcting a bug performed by the bug correction apparatus 100 shown in FIG. 4 includes steps processed time-sequentially by the bug correction apparatus 100 according to the embodiment shown in FIG. 1 . Therefore, even if the content is omitted below, it is also applied to the method of correcting a bug performed by the bug correction apparatus 100 according to the embodiment shown in FIG. 1 .

In step S410, the bug correction device 100 may receive the source code of the program.

In step S420, the bug correction apparatus 100 may identify the location of a buggy line where a bug exists from the source code and verification information about the program based on the auto-encoder and the CNN.

In step S430, the bug correction apparatus 100 may input the code of the buggy line into a sequence hostile generation network-based correction model to generate a correction code in which the bug is corrected.

In the foregoing description, steps S410 to S430 may be further divided into additional steps or combined into fewer steps, depending on the implementation of the present invention. Also, some steps may be omitted as needed, and the order of steps may be switched.

The method of correcting a bug in the bug correction apparatus described with reference to FIGS. 1 to 4 may be implemented in the form of a computer program stored in a medium executed by a computer or a recording medium including instructions executable by a computer.

Computer readable media can be any available media that can be accessed by a computer and includes both volatile and nonvolatile media, removable and non-removable media. Also, computer readable media may include computer storage media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data.

The above description of the present invention is for illustrative purposes, and those skilled in the art can understand that it can be easily modified into other specific forms without changing the technical spirit or essential features of the present invention. will be. Therefore, the embodiments described above should be understood as illustrative in all respects and not limiting. For example, each component described as a single type may be implemented in a distributed manner, and similarly, components described as distributed may be implemented in a combined form.

The scope of the present invention is indicated by the following claims rather than the detailed description above, and all changes or modifications derived from the meaning and scope of the claims and equivalent concepts should be construed as being included in the scope of the present invention. do.

100: bug correction device
110: input unit
120: bug location identification unit
130: bug corrector
140: learning unit
150: conversion unit
160: test unit

Claims (10)

In the bug correction device,
an input unit for receiving the source code of the program;
a bug location identification unit that identifies a location of a buggy line where a bug exists from the source code and verification information about the program based on an autoencoder and a convolution neural network (CNN); and
and a bug correction unit generating a correction code in which the bug is corrected by inputting the code of the buggy line into a correction model based on a sequence generative adversarial network.
According to claim 1,
a conversion unit that converts the program based on the correction code; and
A test unit that performs a conformance test on the source code of the converted program.
Further comprising a bug correction device.
According to claim 1,
The verification information includes a bug report and a stack trace for the program.
According to claim 1,
The bug location identification unit extracts one or more features from the source code and the verification information, inputs the extracted one or more features to an encoder of an auto encoder, and inputs a latent vector output from the encoder to the CNN to determine the CNN. identifying the location of the buggy line from the output of
According to claim 1,
The correction model includes a Recurrent Neural Network (RNN)-based generation model for generating source code and a CNN-based identification model for identifying whether or not the source code generated by the generation model is normal.
According to claim 5,
Further comprising a learning unit for learning the correction model,
The learning unit trains the identification model so that the generation model generates normal or abnormal source code, and the identification model identifies whether the normal or abnormal source code is normal,
and learning the auto-encoder so that an input value and an output value of the auto-encoder are the same.
According to claim 1,
Wherein the bug correcting unit generates a common word dictionary and a user word dictionary based on the source code of the program.
According to claim 2,
wherein the conversion unit applies the correction code to the buggy line and converts the program using a variable name recovery technique.
According to claim 2,
Wherein the test unit performs the conformance test based on a plurality of test cases, and determines that bug correction is suitable when the source code of the converted program passes all of the plurality of test cases.
In the bug correction method,
Receiving the source code of the program;
Identifying a location of a buggy line where a bug exists from the source code and verification information for the program based on an autoencoder and a convolution neural network (CNN); and
Generating a correction code in which the bug is corrected by inputting the code of the buggy line into a correction model based on a sequence adversarial network (Sequence Generative Adversarial Network).
Including, bug correction method.

Images