如何使用机器学习自动修复bug: 上手指南

通过机器学习可以自动修复bug? 对于很多同学来说可能这是一个玄幻的话题。
究竟靠不靠谱，我们可以自己亲自来试试，每个人都能学会。

这个问题说难非常难，说简单也很简单。我们把有bug的代码片断和修复之后的代码片断做成数据集，使用类似机器翻译的技术进行训练。然后我们用训练好的模型去预测新代码如何修复。
这个思想和数据集都来自论文《An Empirical Study on Learning Bug-Fixing Patches in the Wild via Neural Machine Translation》

代码自动修复的题目很简单，一段是有bug的代码，另一段是修复之后的代码。

其主要过程我们看图：

image

为了更广地适应代码的情况，作者对于代码进行了抽象：

image

我们来看一个数据集中的例子：

有bug的代码是这样的：

public java.lang.String METHOD_1 ( ) { return new TYPE_1 ( STRING_1 ) . format ( VAR_1 [ ( ( VAR_1 . length ) - 1 ) ] . getTime ( ) ) ; }

修复之后是这样子的：

public java.lang.String METHOD_1 ( ) { return new TYPE_1 ( STRING_1 ) . format ( VAR_1 [ ( ( type ) - 1 ) ] . getTime ( ) ) ; }

手把手教你用CodeBERT自动修复bug

在为软件工程服务的人工智能AI4SE方面，微软一直是保持领先的。我们下面就手把手学习下如何使用微软的CodeBERT模型来自动修复bug.

第一步：安装transformers框架，因为CodeBERT 是基于这个框架的：

pip install transformers --user

第二步：安装PyTorch或者Tensorflow作为Transformers的后端，驱动能搞定的话，索性就安装最新的吧：

pip install torch torchvision torchtext torchaudio --user

第三步，下载微软的数据集

git clone https://github.com/microsoft/CodeXGLUE

数据集已经被下载到CodeXGLUE/Code-Code/code-refinement/data/ 中了，分为small和medium两个数据集。

我们先拿small数据集练练手:

cd code
export pretrained_model=microsoft/codebert-base
export output_dir=./output
python run.py \
    --do_train \
    --do_eval \
    --model_type roberta \
    --model_name_or_path $pretrained_model \
    --config_name roberta-base \
    --tokenizer_name roberta-base \
    --train_filename ../data/small/train.buggy-fixed.buggy,../data/small/train.buggy-fixed.fixed \
    --dev_filename ../data/small/valid.buggy-fixed.buggy,../data/small/valid.buggy-fixed.fixed \
    --output_dir $output_dir \
    --max_source_length 256 \
    --max_target_length 256 \
    --beam_size 5 \
    --train_batch_size 16 \
    --eval_batch_size 16 \
    --learning_rate 5e-5 \
    --train_steps 100000 \
    --eval_steps 5000

取决于你的机器的算力，我用一台NVIDIA 3090GPU大约训练一晚上时间就训练完了。效果最好的模型被存储于output_dir/checkpoint-best-bleu/pytorch_model.bin中。

然后我们就可以使用测试集检验下我们的训练成果：

python run.py \
    --do_test \
    --model_type roberta \
    --model_name_or_path roberta-base \
    --config_name roberta-base \
    --tokenizer_name roberta-base  \
    --load_model_path $output_dir/checkpoint-best-bleu/pytorch_model.bin \
    --dev_filename ../data/small/valid.buggy-fixed.buggy,../data/small/valid.buggy-fixed.fixed \
    --test_filename ../data/small/test.buggy-fixed.buggy,../data/small/test.buggy-fixed.fixed \
    --output_dir $output_dir \
    --max_source_length 256 \
    --max_target_length 256 \
    --beam_size 5 \
    --eval_batch_size 16 

在我的机器上，经过半小时的推理计算，输出是这样的：

10/26/2021 11:51:57 - INFO - __main__ -   Test file: ../data/small/test.buggy-fixed.buggy,../data/small/test.buggy-fixed.fixed
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 365/365 [30:40<00:00,  5.04s/it]
10/26/2021 12:22:39 - INFO - __main__ -     bleu-4 = 79.26 
10/26/2021 12:22:39 - INFO - __main__ -     xMatch = 16.3325 
10/26/2021 12:22:39 - INFO - __main__ -     ********************

如何评价我们生成的代码质量好不好呢？我们可以通过比较我们生成的output/test_1.output和output/test_1.gold进行比较，可以使用下面的evaluator.py脚本：

python evaluator/evaluator.py -ref ./code/output/test_1.gold -pre ./code/output/test_1.output

输出结果如下：

BLEU: 79.26 ; Acc: 16.33

前者是描述NLP生成质量的BLEU指标，后者是准确率。

这个指标水平如何呢？我们可以跟基线对比下：

准确率虽然看起来不高，但是CodeBERT已经比原论文使用的RNN技术提升了60%了。

我们通过diff来直观感受下生成的和原始的之间的差别：

自动发现bug

如果觉得自动解决bug这个事情离实用还远，我们可以先只发现bug。
可别小看自动发现bug这个相对弱的命题，它带来的适用性和准确率都有较大提升。

是否有bug的数据集特别简单，只要用一个字段来标志是不是有bug就可以了。

数据集格式如下，以jsonl的格式存储：

{"project": "qemu", "commit_id": "aa1530dec499f7525d2ccaa0e3a876dc8089ed1e", "target": 1, "func": "static void filter_mirror_setup(NetFilterState *nf, Error **errp)\n{\n    MirrorState *s = FILTER_MIRROR(nf);\n    Chardev *chr;\n    chr = qemu_chr_find(s->outdev);\n    if (chr == NULL) {\n        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,\n                  \"Device '%s' not found\", s->outdev);\n    qemu_chr_fe_init(&s->chr_out, chr, errp);", "idx": 8}
{"project": "qemu", "commit_id": "21ce148c7ec71ee32834061355a5ecfd1a11f90f", "target": 1, "func": "static inline int64_t sub64(const int64_t a, const int64_t b)\n\n{\n\n\treturn a - b;\n\n}\n", "idx": 10}

不需要写什么代码，我们直接训练：

python run.py \
    --output_dir=./saved_models \
    --model_type=roberta \
    --tokenizer_name=microsoft/codebert-base \
    --model_name_or_path=microsoft/codebert-base \
    --do_train \
    --train_data_file=../dataset/train.jsonl \
    --eval_data_file=../dataset/valid.jsonl \
    --test_data_file=../dataset/test.jsonl \
    --epoch 5 \
    --block_size 200 \
    --train_batch_size 32 \
    --eval_batch_size 64 \
    --learning_rate 2e-5 \
    --max_grad_norm 1.0 \
    --evaluate_during_training \
    --seed 123456

这个时间比自动修复的要短的多，20分钟全搞定。
然后运行下测试集：

python run.py \
    --output_dir=./saved_models \
    --model_type=roberta \
    --tokenizer_name=microsoft/codebert-base \
    --model_name_or_path=microsoft/codebert-base \
    --do_eval \
    --do_test \
    --train_data_file=../dataset/train.jsonl \
    --eval_data_file=../dataset/valid.jsonl \
    --test_data_file=../dataset/test.jsonl \
    --epoch 5 \
    --block_size 200 \
    --train_batch_size 32 \
    --eval_batch_size 64 \
    --learning_rate 2e-5 \
    --max_grad_norm 1.0 \
    --evaluate_during_training \
    --seed 123456

计算一下准确率：

python ../evaluator/evaluator.py -a ../dataset/test.jsonl -p saved_models/predictions.txt

运行结果如下：

{'Acc': 0.6288433382137628}

我们跟业界的主流结果对比下：

准确率都及格了哈。
有了这套方法的好处，仍然是我们前面讲的“睡后收入”。只要积累更多的有效数据，它的识别能力会持续增长，这其中基本上不需要的维护的人力。