add code refinement

Code-Code/code-refinement/code/bleu.py

@@ -0,0 +1,134 @@
+# Copyright 2017 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Python implementation of BLEU and smooth-BLEU.
+
+This module provides a Python implementation of BLEU and smooth-BLEU.
+Smooth BLEU is computed following the method outlined in the paper:
+Chin-Yew Lin, Franz Josef Och. ORANGE: a method for evaluating automatic
+evaluation metrics for machine translation. COLING 2004.
+"""
+
+import collections
+import math
+
+
+def _get_ngrams(segment, max_order):
+  """Extracts all n-grams upto a given maximum order from an input segment.
+
+  Args:
+    segment: text segment from which n-grams will be extracted.
+    max_order: maximum length in tokens of the n-grams returned by this
+        methods.
+
+  Returns:
+    The Counter containing all n-grams upto max_order in segment
+    with a count of how many times each n-gram occurred.
+  """
+  ngram_counts = collections.Counter()
+  for order in range(1, max_order + 1):
+    for i in range(0, len(segment) - order + 1):
+      ngram = tuple(segment[i:i+order])
+      ngram_counts[ngram] += 1
+  return ngram_counts
+
+
+def compute_bleu(reference_corpus, translation_corpus, max_order=4,
+                 smooth=False):
+  """Computes BLEU score of translated segments against one or more references.
+
+  Args:
+    reference_corpus: list of lists of references for each translation. Each
+        reference should be tokenized into a list of tokens.
+    translation_corpus: list of translations to score. Each translation
+        should be tokenized into a list of tokens.
+    max_order: Maximum n-gram order to use when computing BLEU score.
+    smooth: Whether or not to apply Lin et al. 2004 smoothing.
+
+  Returns:
+    3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
+    precisions and brevity penalty.
+  """
+  matches_by_order = [0] * max_order
+  possible_matches_by_order = [0] * max_order
+  reference_length = 0
+  translation_length = 0
+  for (references, translation) in zip(reference_corpus,
+                                       translation_corpus):
+    reference_length += min(len(r) for r in references)
+    translation_length += len(translation)
+
+    merged_ref_ngram_counts = collections.Counter()
+    for reference in references:
+      merged_ref_ngram_counts |= _get_ngrams(reference, max_order)
+    translation_ngram_counts = _get_ngrams(translation, max_order)
+    overlap = translation_ngram_counts & merged_ref_ngram_counts
+    for ngram in overlap:
+      matches_by_order[len(ngram)-1] += overlap[ngram]
+    for order in range(1, max_order+1):
+      possible_matches = len(translation) - order + 1
+      if possible_matches > 0:
+        possible_matches_by_order[order-1] += possible_matches
+
+  precisions = [0] * max_order
+  for i in range(0, max_order):
+    if smooth:
+      precisions[i] = ((matches_by_order[i] + 1.) /
+                       (possible_matches_by_order[i] + 1.))
+    else:
+      if possible_matches_by_order[i] > 0:
+        precisions[i] = (float(matches_by_order[i]) /
+                         possible_matches_by_order[i])
+      else:
+        precisions[i] = 0.0
+
+  if min(precisions) > 0:
+    p_log_sum = sum((1. / max_order) * math.log(p) for p in precisions)
+    geo_mean = math.exp(p_log_sum)
+  else:
+    geo_mean = 0
+
+  ratio = float(translation_length) / reference_length
+
+  if ratio > 1.0:
+    bp = 1.
+  else:
+    bp = math.exp(1 - 1. / ratio)
+
+  bleu = geo_mean * bp
+
+  return (bleu, precisions, bp, ratio, translation_length, reference_length)
+
+
+def _bleu(ref_file, trans_file, subword_option=None):
+    max_order = 4
+    smooth = True
+    ref_files = [ref_file]
+    reference_text = []
+    for reference_filename in ref_files:
+        with open(reference_filename) as fh:
+            reference_text.append(fh.readlines())
+    per_segment_references = []
+    for references in zip(*reference_text):
+        reference_list = []
+        for reference in references:
+            reference_list.append(reference.strip().split())
+        per_segment_references.append(reference_list)
+    translations = []
+    with open(trans_file) as fh:
+        for line in fh:
+            translations.append(line.strip().split())
+    bleu_score, _, _, _, _, _ = compute_bleu(per_segment_references, translations, max_order, smooth)
+    return round(100 * bleu_score,2)

Code-Code/code-refinement/code/eval.sh

@@ -0,0 +1,17 @@
+pretrained_model=microsoft/codebert-base
+output_dir=../model
+data_size=small
+
+CUDA_VISIBLE_DEVICES=1 python run.py \
+    --do_test \
+	--model_type roberta \
+	--model_name_or_path $pretrained_model \
+	--config_name roberta-base \
+	--tokenizer_name roberta-base  \
+	--load_model_path $output_dir/epoch_34/subject_model.pth \
+	--dev_filename ../data/$data_size/valid.buggy-fixed.buggy,../data/$data_size/valid.buggy-fixed.fixed \
+	--output_dir $output_dir \
+	--max_source_length 256 \
+	--max_target_length 256 \
+	--beam_size 5 \
+	--eval_batch_size 16 

Code-Code/code-refinement/code/evaluate.sh

@@ -0,0 +1,3 @@
+python evaluator.py \
+-ref ../data/small/valid.buggy-fixed.fixed \
+-pre ../model/test_0.output

Code-Code/code-refinement/code/evaluator.py

@@ -0,0 +1,35 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+import logging
+import sys
+
+from bleu import _bleu
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Evaluate leaderboard predictions for BigCloneBench dataset.')
+    parser.add_argument('--references', '-ref',help="filename of the labels, in txt format.")
+    parser.add_argument('--predictions', '-pre',help="filename of the leaderboard predictions, in txt format.")
+    
+    args = parser.parse_args()
+
+    refs = [x.strip() for x in open(args.references, 'r', encoding='utf-8').readlines()]
+    pres = [x.strip() for x in open(args.predictions, 'r', encoding='utf-8').readlines()]
+    
+    assert len(refs) == len(pres)
+
+    length = len(refs)
+    count = 0
+    for i in range(length):
+    	r = refs[i]
+    	p = pres[i]
+    	if r == p:
+    		count += 1
+    acc = round(count/length*100, 2)
+    
+    bleu_score = round(_bleu(args.references, args.predictions),2)
+    
+    print('BLEU:',  bleu_score, '; Acc:', acc)
+    
+if __name__ == '__main__':
+    main()

Code-Code/code-refinement/code/model.py

@@ -0,0 +1,223 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+
+import torch
+import torch.nn as nn
+import torch
+from torch.autograd import Variable
+import copy
+class Seq2Seq(nn.Module):
+    """
+        Build Seqence-to-Sequence.
+        
+        Parameters:
+
+        * `encoder`- encoder of seq2seq model. e.g. roberta
+        * `decoder`- decoder of seq2seq model. e.g. transformer
+        * `config`- configuration of encoder model. 
+        * `beam_size`- beam size for beam search. 
+        * `max_length`- max length of target for beam search. 
+        * `sos_id`- start of symbol ids in target for beam search.
+        * `eos_id`- end of symbol ids in target for beam search. 
+    """
+    def __init__(self, encoder,decoder,config,beam_size=None,max_length=None,sos_id=None,eos_id=None):
+        super(Seq2Seq, self).__init__()
+        self.encoder = encoder
+        self.decoder=decoder
+        self.config=config
+        self.register_buffer("bias", torch.tril(torch.ones(2048, 2048)))
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+        self.lsm = nn.LogSoftmax(dim=-1)
+        self.tie_weights()
+        
+        self.beam_size=beam_size
+        self.max_length=max_length
+        self.sos_id=sos_id
+        self.eos_id=eos_id
+        
+    def _tie_or_clone_weights(self, first_module, second_module):
+        """ Tie or clone module weights depending of weither we are using TorchScript or not
+        """
+        if self.config.torchscript:
+            first_module.weight = nn.Parameter(second_module.weight.clone())
+        else:
+            first_module.weight = second_module.weight
+                  
+    def tie_weights(self):
+        """ Make sure we are sharing the input and output embeddings.
+            Export to TorchScript can't handle parameter sharing so we are cloning them instead.
+        """
+        self._tie_or_clone_weights(self.lm_head,
+                                   self.encoder.embeddings.word_embeddings)        
+        
+    def forward(self, source_ids=None,source_mask=None,target_ids=None,target_mask=None,args=None, return_vec=None):   
+        outputs = self.encoder(source_ids, attention_mask=source_mask)
+        if return_vec:
+            return outputs.pooler_output
+
+        encoder_output = outputs[0].permute([1,0,2]).contiguous()
+        
+        if target_ids is not None:  
+            attn_mask=-1e4 *(1-self.bias[:target_ids.shape[1],:target_ids.shape[1]])
+            tgt_embeddings = self.encoder.embeddings(target_ids).permute([1,0,2]).contiguous()
+            out = self.decoder(tgt_embeddings,encoder_output,tgt_mask=attn_mask,memory_key_padding_mask=(1-source_mask).bool())
+            hidden_states = torch.tanh(self.dense(out)).permute([1,0,2]).contiguous()
+            lm_logits = self.lm_head(hidden_states)
+            # Shift so that tokens < n predict n
+            active_loss = target_mask[..., 1:].ne(0).view(-1) == 1
+            shift_logits = lm_logits[..., :-1, :].contiguous()
+            shift_labels = target_ids[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = nn.CrossEntropyLoss(ignore_index=-1)
+            loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1))[active_loss],
+                            shift_labels.view(-1)[active_loss])
+
+            outputs = loss,loss*active_loss.sum(),active_loss.sum()
+            return outputs
+        else:
+            #Predict 
+            preds=[]       
+            zero=torch.cuda.LongTensor(1).fill_(0)     
+            for i in range(source_ids.shape[0]):
+                context=encoder_output[:,i:i+1]
+                context_mask=source_mask[i:i+1,:]
+                beam = Beam(self.beam_size,self.sos_id,self.eos_id)
+                input_ids=beam.getCurrentState()
+                context=context.repeat(1, self.beam_size,1)
+                context_mask=context_mask.repeat(self.beam_size,1)
+                for _ in range(self.max_length): 
+                    if beam.done():
+                        break
+                    attn_mask=-1e4 *(1-self.bias[:input_ids.shape[1],:input_ids.shape[1]])
+                    tgt_embeddings = self.encoder.embeddings(input_ids).permute([1,0,2]).contiguous()
+                    out = self.decoder(tgt_embeddings,context,tgt_mask=attn_mask,memory_key_padding_mask=(1-context_mask).bool())
+                    out = torch.tanh(self.dense(out))
+                    hidden_states=out.permute([1,0,2]).contiguous()[:,-1,:]
+                    out = self.lsm(self.lm_head(hidden_states)).data
+                    beam.advance(out)
+                    input_ids.data.copy_(input_ids.data.index_select(0, beam.getCurrentOrigin()))
+                    input_ids=torch.cat((input_ids,beam.getCurrentState()),-1)
+                hyp= beam.getHyp(beam.getFinal())
+                pred=beam.buildTargetTokens(hyp)[:self.beam_size]
+                pred=[torch.cat([x.view(-1) for x in p]+[zero]*(self.max_length-len(p))).view(1,-1) for p in pred]
+                preds.append(torch.cat(pred,0).unsqueeze(0))
+                
+            preds=torch.cat(preds,0)                
+            return preds   
+        
+        
+
+class Beam(object):
+    def __init__(self, size,sos,eos):
+        self.size = size
+        self.tt = torch.cuda
+        # The score for each translation on the beam.
+        self.scores = self.tt.FloatTensor(size).zero_()
+        # The backpointers at each time-step.
+        self.prevKs = []
+        # The outputs at each time-step.
+        self.nextYs = [self.tt.LongTensor(size)
+                       .fill_(0)]
+        self.nextYs[0][0] = sos
+        # Has EOS topped the beam yet.
+        self._eos = eos
+        self.eosTop = False
+        # Time and k pair for finished.
+        self.finished = []
+
+    def getCurrentState(self):
+        "Get the outputs for the current timestep."
+        batch = self.tt.LongTensor(self.nextYs[-1]).view(-1, 1)
+        return batch
+
+    def getCurrentOrigin(self):
+        "Get the backpointers for the current timestep."
+        return self.prevKs[-1]
+
+    def advance(self, wordLk):
+        """
+        Given prob over words for every last beam `wordLk` and attention
+        `attnOut`: Compute and update the beam search.
+
+        Parameters:
+
+        * `wordLk`- probs of advancing from the last step (K x words)
+        * `attnOut`- attention at the last step
+
+        Returns: True if beam search is complete.
+        """
+        numWords = wordLk.size(1)
+
+        # Sum the previous scores.
+        if len(self.prevKs) > 0:
+            beamLk = wordLk + self.scores.unsqueeze(1).expand_as(wordLk)
+
+            # Don't let EOS have children.
+            for i in range(self.nextYs[-1].size(0)):
+                if self.nextYs[-1][i] == self._eos:
+                    beamLk[i] = -1e20
+        else:
+            beamLk = wordLk[0]
+        flatBeamLk = beamLk.view(-1)
+        bestScores, bestScoresId = flatBeamLk.topk(self.size, 0, True, True)
+
+        self.scores = bestScores
+
+        # bestScoresId is flattened beam x word array, so calculate which
+        # word and beam each score came from
+        prevK = bestScoresId // numWords
+        self.prevKs.append(prevK)
+        self.nextYs.append((bestScoresId - prevK * numWords))
+
+
+        for i in range(self.nextYs[-1].size(0)):
+            if self.nextYs[-1][i] == self._eos:
+                s = self.scores[i]
+                self.finished.append((s, len(self.nextYs) - 1, i))
+
+        # End condition is when top-of-beam is EOS and no global score.
+        if self.nextYs[-1][0] == self._eos:
+            self.eosTop = True
+
+    def done(self):
+        return self.eosTop and len(self.finished) >=self.size
+
+    def getFinal(self):
+        if len(self.finished) == 0:
+            self.finished.append((self.scores[0], len(self.nextYs) - 1, 0))
+        self.finished.sort(key=lambda a: -a[0])
+        if len(self.finished) != self.size:
+            unfinished=[]
+            for i in range(self.nextYs[-1].size(0)):
+                if self.nextYs[-1][i] != self._eos:
+                    s = self.scores[i]
+                    unfinished.append((s, len(self.nextYs) - 1, i)) 
+            unfinished.sort(key=lambda a: -a[0])
+            self.finished+=unfinished[:self.size-len(self.finished)]
+        return self.finished[:self.size]
+
+    def getHyp(self, beam_res):
+        """
+        Walk back to construct the full hypothesis.
+        """
+        hyps=[]
+        for _,timestep, k in beam_res:
+            hyp = []
+            for j in range(len(self.prevKs[:timestep]) - 1, -1, -1):
+                hyp.append(self.nextYs[j+1][k])
+                k = self.prevKs[j][k]
+            hyps.append(hyp[::-1])
+        return hyps
+    
+    def buildTargetTokens(self, preds):
+        sentence=[]
+        for pred in preds:
+            tokens = []
+            for tok in pred:
+                if tok==self._eos:
+                    break
+                tokens.append(tok)
+            sentence.append(tokens)
+        return sentence
+        

Code-Code/code-refinement/code/run.py

@@ -0,0 +1,575 @@
+# coding=utf-8
+# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for language modeling on a text file (GPT, GPT-2, BERT, RoBERTa).
+GPT and GPT-2 are fine-tuned using a causal language modeling (CLM) loss while BERT and RoBERTa are fine-tuned
+using a masked language modeling (MLM) loss.
+"""
+
+from __future__ import absolute_import
+import os
+import sys
+import pickle
+import torch
+import json
+import random
+import logging
+import argparse
+import numpy as np
+from io import open
+from itertools import cycle
+import torch.nn as nn
+from model import Seq2Seq
+from tqdm import tqdm, trange
+from bleu import _bleu
+from torch.utils.data import DataLoader, Dataset, SequentialSampler, RandomSampler,TensorDataset
+from torch.utils.data.distributed import DistributedSampler
+from transformers import (WEIGHTS_NAME, AdamW, get_linear_schedule_with_warmup,
+                          RobertaConfig, RobertaModel, RobertaTokenizer)
+MODEL_CLASSES = {'roberta': (RobertaConfig, RobertaModel, RobertaTokenizer)}
+
+logging.basicConfig(format = '%(asctime)s - %(levelname)s - %(name)s -   %(message)s',
+                    datefmt = '%m/%d/%Y %H:%M:%S',
+                    level = logging.INFO)
+logger = logging.getLogger(__name__)
+
+class Example(object):
+    """A single training/test example."""
+    def __init__(self,
+                 idx,
+                 source,
+                 target,
+                 ):
+        self.idx = idx
+        self.source = source
+        self.target = target
+
+# def read_examples(filename):
+#     """Read examples from filename."""
+#     examples=[]
+#     with open(filename,encoding="utf-8") as f:
+#         for idx,js in enumerate(json.load(f)):
+#             source=' '.join(js['old_comment_tokens'])
+#             target=' '.join(js['new_comment_tokens'])      
+#             examples.append(
+#                 Example(
+#                         idx = idx,
+#                         source=source,
+#                         target=target,
+#                         ) 
+#             )
+#     return examples
+def read_examples(filename):
+    """Read examples from filename."""
+    examples=[]
+    assert len(filename.split(','))==2
+    src_filename = filename.split(',')[0]
+    trg_filename = filename.split(',')[1]
+    idx = 0
+    with open(src_filename) as f1,open(trg_filename) as f2:
+            for line1,line2 in zip(f1,f2):
+                examples.append(
+                Example(
+                        idx = idx,
+                        source=line1.strip(),
+                        target=line2.strip(),
+                        ) 
+                )
+                idx+=1
+    return examples
+
+class InputFeatures(object):
+    """A single training/test features for a example."""
+    def __init__(self,
+                 example_id,
+                 source_ids,
+                 target_ids,
+                 source_mask,
+                 target_mask,
+
+    ):
+        self.example_id = example_id
+        self.source_ids = source_ids
+        self.target_ids = target_ids
+        self.source_mask = source_mask
+        self.target_mask = target_mask       
+        
+
+
+def convert_examples_to_features(examples, tokenizer, args,stage=None):
+    features = []
+    for example_index, example in enumerate(examples):
+        #source
+        source_tokens = tokenizer.tokenize(example.source)[:args.max_source_length-2]
+        source_tokens =[tokenizer.cls_token]+source_tokens+[tokenizer.sep_token]
+        source_ids =  tokenizer.convert_tokens_to_ids(source_tokens) 
+        source_mask = [1] * (len(source_tokens))
+        padding_length = args.max_source_length - len(source_ids)
+        source_ids+=[tokenizer.pad_token_id]*padding_length
+        source_mask+=[0]*padding_length
+ 
+        #target
+        if stage=="test":
+            target_tokens = tokenizer.tokenize("None")
+        else:
+            target_tokens = tokenizer.tokenize(example.target)[:args.max_target_length-2]
+        target_tokens = [tokenizer.cls_token]+target_tokens+[tokenizer.sep_token]            
+        target_ids = tokenizer.convert_tokens_to_ids(target_tokens)
+        target_mask = [1] *len(target_ids)
+        padding_length = args.max_target_length - len(target_ids)
+        target_ids+=[tokenizer.pad_token_id]*padding_length
+        target_mask+=[0]*padding_length   
+   
+        if example_index < 5:
+            if stage=='train':
+                logger.info("*** Example ***")
+                logger.info("idx: {}".format(example.idx))
+
+                logger.info("source_tokens: {}".format([x.replace('\u0120','_') for x in source_tokens]))
+                logger.info("source_ids: {}".format(' '.join(map(str, source_ids))))
+                logger.info("source_mask: {}".format(' '.join(map(str, source_mask))))
+                
+                logger.info("target_tokens: {}".format([x.replace('\u0120','_') for x in target_tokens]))
+                logger.info("target_ids: {}".format(' '.join(map(str, target_ids))))
+                logger.info("target_mask: {}".format(' '.join(map(str, target_mask))))
+       
+        features.append(
+            InputFeatures(
+                 example_index,
+                 source_ids,
+                 target_ids,
+                 source_mask,
+                 target_mask,
+            )
+        )
+    return features
+
+
+def _truncate_seq_pair(tokens_a, tokens_b,tokens_c, max_length):
+    """Truncates a sequence pair in place to the maximum length."""
+
+    # This is a simple heuristic which will always truncate the longer sequence
+    # one token at a time. This makes more sense than truncating an equal percent
+    # of tokens from each, since if one sequence is very short then each token
+    # that's truncated likely contains more information than a longer sequence.
+    
+    while True:
+        total_length = len(tokens_a) + len(tokens_b)+len(tokens_c)
+        if total_length <= max_length:
+            break
+        if len(tokens_a) >= len(tokens_b) and len(tokens_a)>=len(tokens_c):
+            tokens_a.pop()
+        elif len(tokens_b) >= len(tokens_a) and len(tokens_b)>=len(tokens_c):
+            tokens_b.pop()
+        else:
+            tokens_c.pop()
+
+def set_seed(args):
+    """set random seed."""
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    if args.n_gpu > 0:
+        torch.cuda.manual_seed_all(args.seed)
+        
+def main():
+    parser = argparse.ArgumentParser()
+
+    ## Required parameters  
+    parser.add_argument("--model_type", default=None, type=str, required=True,
+                        help="Model type: e.g. roberta")
+    parser.add_argument("--model_name_or_path", default=None, type=str, required=True,
+                        help="Path to pre-trained model: e.g. roberta-base" )
+    parser.add_argument("--tokenizer_name", default="", required=True,
+                        help="Pretrained tokenizer name or path if not the same as model_name")    
+    parser.add_argument("--output_dir", default=None, type=str, required=True,
+                        help="The output directory where the model predictions and checkpoints will be written.")
+    parser.add_argument("--load_model_path", default=None, type=str, 
+                        help="Path to trained model: Should contain the .bin files" )    
+    ## Other parameters
+    parser.add_argument("--train_filename", default=None, type=str,
+                        help="The train filenames (source and target files).")
+    parser.add_argument("--dev_filename", default=None, type=str,
+                        help="The dev filename. (source and target files).")
+    parser.add_argument("--test_filename", default=None, type=str,
+                        help="The test filename. (source and target files).")  
+    
+    parser.add_argument("--config_name", default="", type=str,
+                        help="Pretrained config name or path if not the same as model_name")
+
+    parser.add_argument("--max_source_length", default=64, type=int,
+                        help="The maximum total source sequence length after tokenization. Sequences longer "
+                             "than this will be truncated, sequences shorter will be padded.")
+    parser.add_argument("--max_target_length", default=32, type=int,
+                        help="The maximum total target sequence length after tokenization. Sequences longer "
+                             "than this will be truncated, sequences shorter will be padded.")
+    
+    parser.add_argument("--do_train", action='store_true',
+                        help="Whether to run training.")
+    parser.add_argument("--do_eval", action='store_true',
+                        help="Whether to run eval on the dev set.")
+    parser.add_argument("--do_test", action='store_true',
+                        help="Whether to run eval on the dev set.")
+    parser.add_argument("--do_lower_case", action='store_true',
+                        help="Set this flag if you are using an uncased model.")
+    parser.add_argument("--no_cuda", action='store_true',
+                        help="Avoid using CUDA when available") 
+    
+    parser.add_argument("--train_batch_size", default=8, type=int,
+                        help="Batch size per GPU/CPU for training.")
+    parser.add_argument("--eval_batch_size", default=8, type=int,
+                        help="Batch size per GPU/CPU for evaluation.")
+    parser.add_argument('--gradient_accumulation_steps', type=int, default=1,
+                        help="Number of updates steps to accumulate before performing a backward/update pass.")
+    parser.add_argument("--learning_rate", default=5e-5, type=float,
+                        help="The initial learning rate for Adam.")
+    parser.add_argument("--beam_size", default=10, type=int,
+                        help="beam size for beam search")    
+    parser.add_argument("--weight_decay", default=0.0, type=float,
+                        help="Weight deay if we apply some.")
+    parser.add_argument("--adam_epsilon", default=1e-8, type=float,
+                        help="Epsilon for Adam optimizer.")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float,
+                        help="Max gradient norm.")
+    parser.add_argument("--num_train_epochs", default=3.0, type=float,
+                        help="Total number of training epochs to perform.")
+    parser.add_argument("--max_steps", default=-1, type=int,
+                        help="If > 0: set total number of training steps to perform. Override num_train_epochs.")
+    parser.add_argument("--eval_steps", default=-1, type=int,
+                        help="")
+    parser.add_argument("--train_steps", default=-1, type=int,
+                        help="")
+    parser.add_argument("--warmup_steps", default=0, type=int,
+                        help="Linear warmup over warmup_steps.")
+    parser.add_argument("--local_rank", type=int, default=-1,
+                        help="For distributed training: local_rank")   
+    parser.add_argument('--seed', type=int, default=42,
+                        help="random seed for initialization")
+    # print arguments
+    args = parser.parse_args()
+    logger.info(args)
+
+    # Setup CUDA, GPU & distributed training
+    if args.local_rank == -1 or args.no_cuda:
+        device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
+        args.n_gpu = torch.cuda.device_count()
+    else:  # Initializes the distributed backend which will take care of sychronizing nodes/GPUs
+        torch.cuda.set_device(args.local_rank)
+        device = torch.device("cuda", args.local_rank)
+        torch.distributed.init_process_group(backend='nccl')
+        args.n_gpu = 1
+    logger.warning("Process rank: %s, device: %s, n_gpu: %s, distributed training: %s",
+                    args.local_rank, device, args.n_gpu, bool(args.local_rank != -1))
+    args.device = device
+    # Set seed
+    set_seed(args)
+    # make dir if output_dir not exist
+    if os.path.exists(args.output_dir) is False:
+        os.makedirs(args.output_dir)
+        
+    config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
+    config = config_class.from_pretrained(args.config_name if args.config_name else args.model_name_or_path)
+    tokenizer = tokenizer_class.from_pretrained(args.tokenizer_name,do_lower_case=args.do_lower_case)
+    
+    #budild model
+    encoder = model_class.from_pretrained(args.model_name_or_path,config=config)    
+    decoder_layer = nn.TransformerDecoderLayer(d_model=config.hidden_size, nhead=config.num_attention_heads)
+    decoder = nn.TransformerDecoder(decoder_layer, num_layers=6)
+    model=Seq2Seq(encoder=encoder,decoder=decoder,config=config,
+                  beam_size=args.beam_size,max_length=args.max_target_length,
+                  sos_id=tokenizer.cls_token_id,eos_id=tokenizer.sep_token_id)
+    
+    if args.load_model_path is not None:
+        logger.info("reload model from {}".format(args.load_model_path))
+        model.load_state_dict(torch.load(args.load_model_path))
+        
+    model.to(device)
+    if args.local_rank != -1:
+        # Distributed training
+        try:
+            from apex.parallel import DistributedDataParallel as DDP
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use distributed and fp16 training.")
+
+        model = DDP(model)
+    elif args.n_gpu > 1:
+        # multi-gpu training
+        model = torch.nn.DataParallel(model)
+
+
+
+
+    if args.do_train:
+        # Prepare training data loader
+        train_examples = read_examples(args.train_filename)
+        train_features = convert_examples_to_features(train_examples, tokenizer,args,stage='train')
+        all_source_ids = torch.tensor([f.source_ids for f in train_features], dtype=torch.long)
+        all_source_mask = torch.tensor([f.source_mask for f in train_features], dtype=torch.long)
+        all_target_ids = torch.tensor([f.target_ids for f in train_features], dtype=torch.long)
+        all_target_mask = torch.tensor([f.target_mask for f in train_features], dtype=torch.long)    
+        train_data = TensorDataset(all_source_ids,all_source_mask,all_target_ids,all_target_mask)
+        
+        if args.local_rank == -1:
+            train_sampler = RandomSampler(train_data)
+        else:
+            train_sampler = DistributedSampler(train_data)
+        train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=args.train_batch_size//args.gradient_accumulation_steps)
+
+        num_train_optimization_steps =  args.train_steps
+
+        # Prepare optimizer and schedule (linear warmup and decay)
+        no_decay = ['bias', 'LayerNorm.weight']
+        optimizer_grouped_parameters = [
+            {'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
+             'weight_decay': args.weight_decay},
+            {'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
+        ]
+        optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)
+        scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=args.warmup_steps,
+                                                    num_training_steps=num_train_optimization_steps)
+    
+        
+        #Start training
+        logger.info("***** Running training *****")
+        logger.info("  Num examples = %d", len(train_examples))
+        logger.info("  Batch size = %d", args.train_batch_size)
+        logger.info("  Num epoch = %d", num_train_optimization_steps*args.train_batch_size//len(train_examples))
+        
+
+        model.train()
+        dev_dataset={}
+        nb_tr_examples, nb_tr_steps,tr_loss,global_step,best_bleu,best_loss = 0, 0,0,0,0,1e6 
+        bar = range(num_train_optimization_steps)
+        train_dataloader=cycle(train_dataloader)
+        eval_flag = True
+        idx=0
+        for step in bar:
+            batch = next(train_dataloader)
+            batch = tuple(t.to(device) for t in batch)
+            source_ids,source_mask,target_ids,target_mask = batch
+            loss,_,_ = model(source_ids=source_ids,source_mask=source_mask,target_ids=target_ids,target_mask=target_mask)
+            
+            if args.n_gpu > 1:
+                loss = loss.mean() # mean() to average on multi-gpu.
+            if args.gradient_accumulation_steps > 1:
+                loss = loss / args.gradient_accumulation_steps
+            tr_loss += loss.item()
+            train_loss=round(tr_loss*args.gradient_accumulation_steps/(nb_tr_steps+1),4)
+            if (global_step + 1)%100==0:
+                logger.info("  step {} loss {} batch-{}".format(global_step + 1,train_loss, ((global_step+1)*args.train_batch_size) / len(train_examples)))
+            nb_tr_examples += source_ids.size(0)
+            nb_tr_steps += 1
+            loss.backward()
+
+            if (nb_tr_steps + 1) % args.gradient_accumulation_steps == 0:
+                #Update parameters
+                optimizer.step()
+                optimizer.zero_grad()
+                scheduler.step()
+                global_step += 1
+                eval_flag = True
+            
+            
+            if args.do_eval and ((global_step + 1) %args.eval_steps == 0) and eval_flag:
+                #Eval model with dev dataset
+                tr_loss = 0
+                nb_tr_examples, nb_tr_steps = 0, 0                     
+                eval_flag=False    
+                if 'dev_loss' in dev_dataset:
+                    eval_examples,eval_data=dev_dataset['dev_loss']
+                else:
+                    eval_examples = read_examples(args.dev_filename)
+                    eval_features = convert_examples_to_features(eval_examples, tokenizer, args,stage='dev')
+                    all_source_ids = torch.tensor([f.source_ids for f in eval_features], dtype=torch.long)
+                    all_source_mask = torch.tensor([f.source_mask for f in eval_features], dtype=torch.long)
+                    all_target_ids = torch.tensor([f.target_ids for f in eval_features], dtype=torch.long)
+                    all_target_mask = torch.tensor([f.target_mask for f in eval_features], dtype=torch.long)      
+                    eval_data = TensorDataset(all_source_ids,all_source_mask,all_target_ids,all_target_mask)   
+                    dev_dataset['dev_loss']=eval_examples,eval_data
+                eval_sampler = SequentialSampler(eval_data)
+                eval_dataloader = DataLoader(eval_data, sampler=eval_sampler, batch_size=args.eval_batch_size)
+                
+                logger.info("\n***** Running evaluation *****")
+                logger.info("  Num examples = %d", len(eval_examples))
+                logger.info("  Batch size = %d", args.eval_batch_size)
+
+                #Start Evaling model
+                model.eval()
+                eval_loss,tokens_num = 0,0
+                for batch in eval_dataloader:
+                    batch = tuple(t.to(device) for t in batch)
+                    source_ids,source_mask,target_ids,target_mask = batch                  
+
+                    with torch.no_grad():
+                        _,loss,num = model(source_ids=source_ids,source_mask=source_mask,
+                                           target_ids=target_ids,target_mask=target_mask)     
+                    eval_loss += loss.sum().item()
+                    tokens_num += num.sum().item()
+                #Pring loss of dev dataset    
+                model.train()
+                eval_loss = eval_loss / tokens_num
+                result = {'eval_ppl': round(np.exp(eval_loss),5),
+                          'global_step': global_step+1,
+                          'train_loss': round(train_loss,5)}
+                for key in sorted(result.keys()):
+                    logger.info("  %s = %s", key, str(result[key]))
+                logger.info("  "+"*"*20)   
+                
+                #save last checkpoint
+                last_output_dir = os.path.join(args.output_dir, 'checkpoint-last')
+                if not os.path.exists(last_output_dir):
+                    os.makedirs(last_output_dir)
+                model_to_save = model.module if hasattr(model, 'module') else model  # Only save the model it-self
+                output_model_file = os.path.join(last_output_dir, "pytorch_model.bin")
+                torch.save(model_to_save.state_dict(), output_model_file)                    
+                if eval_loss<best_loss:
+                    logger.info("  Best ppl:%s",round(np.exp(eval_loss),5))
+                    logger.info("  "+"*"*20)
+                    best_loss=eval_loss
+                    # Save best checkpoint for best ppl
+                    output_dir = os.path.join(args.output_dir, 'checkpoint-best-ppl')
+                    if not os.path.exists(output_dir):
+                        os.makedirs(output_dir)
+                    model_to_save = model.module if hasattr(model, 'module') else model  # Only save the model it-self
+                    output_model_file = os.path.join(output_dir, "pytorch_model.bin")
+                    torch.save(model_to_save.state_dict(), output_model_file)  
+                            
+                            
+                #Calculate bleu  
+                if 'dev_bleu' in dev_dataset:
+                    eval_examples,eval_data=dev_dataset['dev_bleu']
+                else:
+                    eval_examples = read_examples(args.dev_filename)
+                    eval_examples = random.sample(eval_examples,min(1000,len(eval_examples)))
+                    eval_features = convert_examples_to_features(eval_examples, tokenizer, args,stage='test')
+                    all_source_ids = torch.tensor([f.source_ids for f in eval_features], dtype=torch.long)
+                    all_source_mask = torch.tensor([f.source_mask for f in eval_features], dtype=torch.long)    
+                    eval_data = TensorDataset(all_source_ids,all_source_mask)   
+                    dev_dataset['dev_bleu']=eval_examples,eval_data
+
+
+                eval_sampler = SequentialSampler(eval_data)
+                eval_dataloader = DataLoader(eval_data, sampler=eval_sampler, batch_size=args.eval_batch_size)
+
+                model.eval() 
+                p=[]
+                for batch in eval_dataloader:
+                    batch = tuple(t.to(device) for t in batch)
+                    source_ids,source_mask= batch                  
+                    with torch.no_grad():
+                        preds = model(source_ids=source_ids,source_mask=source_mask)  
+                        for pred in preds:
+                            t=pred[0].cpu().numpy()
+                            t=list(t)
+                            if 0 in t:
+                                t=t[:t.index(0)]
+                            text = tokenizer.decode(t,clean_up_tokenization_spaces=False)
+                            p.append(text)
+                model.train()
+                predictions=[]
+                accs=[]
+                with open(os.path.join(args.output_dir,"dev.output"),'w') as f, open(os.path.join(args.output_dir,"dev.gold"),'w') as f1:
+                    for ref,gold in zip(p,eval_examples):
+                        predictions.append(str(gold.idx)+'\t'+ref)
+                        f.write(ref+'\n')
+                        f1.write(gold.target+'\n')     
+                        accs.append(ref==gold.target)
+
+                dev_bleu=round(_bleu(os.path.join(args.output_dir, "dev.gold"), os.path.join(args.output_dir, "dev.output")),2)
+                logger.info("  %s = %s "%("bleu-4",str(dev_bleu)))
+                logger.info("  %s = %s "%("xMatch",str(round(np.mean(accs)*100,4))))
+                logger.info("  "+"*"*20)    
+                if dev_bleu>best_bleu:
+                    logger.info("  Best bleu:%s",dev_bleu)
+                    logger.info("  "+"*"*20)
+                    best_bleu=dev_bleu
+                    # Save best checkpoint for best bleu
+                    output_dir = os.path.join(args.output_dir, 'checkpoint-best-bleu')
+                    if not os.path.exists(output_dir):
+                        os.makedirs(output_dir)
+                    model_to_save = model.module if hasattr(model, 'module') else model  # Only save the model it-self
+                    output_model_file = os.path.join(output_dir, "pytorch_model.bin")
+                    torch.save(model_to_save.state_dict(), output_model_file)
+
+            # 每一轮记录checkpoint
+            if int((global_step+1)*args.train_batch_size / len(train_examples)) == idx+1:
+                logger.info("  batch:%s",idx)
+                output_dir = os.path.join(args.output_dir, 'epoch_{}'.format(idx+1))
+                if not os.path.exists(output_dir):
+                    os.makedirs(output_dir)
+                model_to_save = model.module if hasattr(model, 'module') else model
+                ckpt_output_path = os.path.join(output_dir, 'subject_model.pth')
+                logger.info("Saving model checkpoint to %s", ckpt_output_path)
+                torch.save(model_to_save.state_dict(), ckpt_output_path)
+                idx = idx+1
+               
+    if args.do_test:
+        files=[]
+        if args.dev_filename is not None:
+            files.append(args.dev_filename)
+        if args.test_filename is not None:
+            files.append(args.test_filename)
+        for idx,file in enumerate(files):   
+            logger.info("Test file: {}".format(file))
+            eval_examples = read_examples(file)
+            eval_features = convert_examples_to_features(eval_examples, tokenizer, args,stage='test')
+            all_source_ids = torch.tensor([f.source_ids for f in eval_features], dtype=torch.long)
+            all_source_mask = torch.tensor([f.source_mask for f in eval_features], dtype=torch.long)    
+            eval_data = TensorDataset(all_source_ids,all_source_mask)   
+
+            # Calculate bleu
+            eval_sampler = SequentialSampler(eval_data)
+            eval_dataloader = DataLoader(eval_data, sampler=eval_sampler, batch_size=args.eval_batch_size)
+
+            model.eval() 
+            p=[]
+            for batch in tqdm(eval_dataloader,total=len(eval_dataloader)):
+                batch = tuple(t.to(device) for t in batch)
+                source_ids,source_mask= batch                  
+                with torch.no_grad():
+                    preds = model(source_ids=source_ids,source_mask=source_mask)  
+                    for pred in preds:
+                        t=pred[0].cpu().numpy()
+                        t=list(t)
+                        if 0 in t:
+                            t=t[:t.index(0)]
+                        text = tokenizer.decode(t,clean_up_tokenization_spaces=False)
+                        p.append(text)
+            model.train()
+            predictions=[]
+            accs=[]
+            with open(os.path.join(args.output_dir,"test_{}.output".format(str(idx))),'w') as f, open(os.path.join(args.output_dir,"test_{}.gold".format(str(idx))),'w') as f1:
+                for ref,gold in zip(p,eval_examples):
+                    predictions.append(str(gold.idx)+'\t'+ref)
+                    f.write(ref+'\n')
+                    f1.write(gold.target+'\n')    
+                    accs.append(ref==gold.target)
+            dev_bleu=round(_bleu(os.path.join(args.output_dir, "test_{}.gold".format(str(idx))).format(file), 
+                                 os.path.join(args.output_dir, "test_{}.output".format(str(idx))).format(file)),2)
+            logger.info("  %s = %s "%("bleu-4",str(dev_bleu)))
+            logger.info("  %s = %s "%("xMatch",str(round(np.mean(accs)*100,4))))
+            logger.info("  "+"*"*20)    
+
+
+
+                            
+
+                
+                
+if __name__ == "__main__":
+    main()
+
+

Code-Code/code-refinement/code/train.sh

@@ -0,0 +1,22 @@
+pretrained_model=microsoft/codebert-base
+output_dir=../model
+data_size=small
+
+CUDA_VISIBLE_DEVICES=1 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/$data_size/train.buggy-fixed.buggy,../data/$data_size/train.buggy-fixed.fixed \
+	--dev_filename ../data/$data_size/valid.buggy-fixed.buggy,../data/$data_size/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

Code-Code/code-refinement/dataset.zip

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

Code-Code/code-refinement/model/small/epoch_1/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_10/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_11/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_12/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_13/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_14/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_15/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_16/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_17/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_18/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_19/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_2/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_20/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_21/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_22/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_23/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_24/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_25/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_26/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_27/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_28/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_29/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_3/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_30/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_31/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_32/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_33/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_34/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_4/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_5/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_6/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_7/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_8/subject_model.pth

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

Code-Code/code-refinement/model/small/epoch_9/subject_model.pth

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