Merge branch 'zyf'

zyf branch have some mtp, so merge it into the main brand to manage them

Code-Code/Clone-detection-BigCloneBench/code/eval.sh

@@ -0,0 +1,19 @@
+CUDA_VISIBLE_DEVICES=0,1 python run.py \
+    --output_dir=../model \
+    --model_type=roberta \
+    --config_name=microsoft/codebert-base \
+    --model_name_or_path=microsoft/codebert-base \
+    --tokenizer_name=roberta-base \
+    --do_eval \
+    --do_test \
+    --train_data_file=../dataset/train.txt \
+    --eval_data_file=../dataset/valid.txt \
+    --test_data_file=../dataset/valid.txt \
+    --epoch 2 \
+    --block_size 400 \
+    --train_batch_size 16 \
+    --eval_batch_size 32 \
+    --learning_rate 5e-5 \
+    --max_grad_norm 1.0 \
+    --evaluate_during_training \
+    --seed 123456

Code-Code/Clone-detection-BigCloneBench/code/evaluate.sh

@@ -0,0 +1,3 @@
+python evaluator.py \
+    -a ../dataset/valid.txt \
+    -p ../model/predictions.txt

Code-Code/Clone-detection-BigCloneBench/code/evaluator.py

@@ -0,0 +1,53 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+import logging
+import sys
+from sklearn.metrics import recall_score,precision_score,f1_score
+
+def read_answers(filename):
+    answers={}
+    with open(filename) as f:
+        for line in f:
+            line=line.strip()
+            idx1,idx2,label=line.split()
+            answers[(idx1,idx2)]=int(label)
+    return answers
+
+def read_predictions(filename):
+    predictions={}
+    with open(filename) as f:
+        for line in f:
+            line=line.strip()
+            idx1,idx2,label=line.split()
+            predictions[(idx1,idx2)]=int(label)
+    return predictions
+
+def calculate_scores(answers,predictions):
+    y_trues,y_preds=[],[]
+    for key in answers:
+        if key not in predictions:
+            logging.error("Missing prediction for ({},{}) pair.".format(key[0],key[1]))
+            sys.exit()
+        y_trues.append(answers[key])
+        y_preds.append(predictions[key])
+    scores={}
+    scores['Recall']=recall_score(y_trues, y_preds)
+    scores['Precision']=precision_score(y_trues, y_preds)
+    scores['F1']=f1_score(y_trues, y_preds)
+    return scores
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Evaluate leaderboard predictions for BigCloneBench dataset.')
+    parser.add_argument('--answers', '-a',help="filename of the labels, in txt format.")
+    parser.add_argument('--predictions', '-p',help="filename of the leaderboard predictions, in txt format.")
+    
+
+    args = parser.parse_args()
+    answers=read_answers(args.answers)
+    predictions=read_predictions(args.predictions)
+    scores=calculate_scores(answers,predictions)
+    print(scores)
+
+if __name__ == '__main__':
+    main()

Code-Code/Clone-detection-BigCloneBench/code/model.py

@@ -0,0 +1,62 @@
+# 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
+import torch.nn.functional as F
+from torch.nn import CrossEntropyLoss, MSELoss
+
+class RobertaClassificationHead(nn.Module):
+    """Head for sentence-level classification tasks."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size*2, config.hidden_size)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.out_proj = nn.Linear(config.hidden_size, 2)
+
+    def forward(self, features, **kwargs):
+        x = features[:, 0, :]  # take <s> token (equiv. to [CLS])
+        x = x.reshape(-1,x.size(-1)*2)
+        x = self.dropout(x)
+        x = self.dense(x)
+        x = torch.tanh(x)
+        x = self.dropout(x)
+        x = self.out_proj(x)
+        return x
+        
+class Model(nn.Module):   
+    def __init__(self, encoder,config,tokenizer,args):
+        super(Model, self).__init__()
+        self.encoder = encoder
+        self.config=config
+        self.tokenizer=tokenizer
+        self.classifier=RobertaClassificationHead(config)
+        self.args=args
+    
+        
+    def forward(self, input_ids=None,labels=None, return_vec=None): 
+        input_ids=input_ids.view(-1,self.args.block_size)
+        outputs = self.encoder(input_ids= input_ids,attention_mask=input_ids.ne(1))
+
+        if return_vec:
+            return outputs.pooler_output
+
+        outputs = outputs[0]
+        logits=self.classifier(outputs)
+        prob=F.softmax(logits)
+
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(logits, labels)
+            return loss,prob
+        else:
+            return prob
+      
+        
+ 
+        
+
+

Code-Code/Clone-detection-BigCloneBench/code/run.py

@@ -0,0 +1,649 @@
+# 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, division, print_function
+
+import argparse
+import glob
+import logging
+import os
+import pickle
+import random
+import re
+import shutil
+import json
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Dataset, SequentialSampler, RandomSampler,TensorDataset
+from torch.utils.data.distributed import DistributedSampler
+
+try:
+    from torch.utils.tensorboard import SummaryWriter
+except:
+    from tensorboardX import SummaryWriter
+
+from tqdm import tqdm, trange
+import multiprocessing
+from model import Model
+
+cpu_cont = 16
+from transformers import (WEIGHTS_NAME, AdamW, get_linear_schedule_with_warmup,
+                          BertConfig, BertForMaskedLM, BertTokenizer,
+                          GPT2Config, GPT2LMHeadModel, GPT2Tokenizer,
+                          OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer,
+                          RobertaConfig, RobertaModel, RobertaTokenizer,
+                          DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer)
+
+logger = logging.getLogger(__name__)
+
+MODEL_CLASSES = {
+    'gpt2': (GPT2Config, GPT2LMHeadModel, GPT2Tokenizer),
+    'openai-gpt': (OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
+    'bert': (BertConfig, BertForMaskedLM, BertTokenizer),
+    'roberta': (RobertaConfig, RobertaModel, RobertaTokenizer),
+    'distilbert': (DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer)
+}
+
+def get_example(item):
+    url1,url2,label,tokenizer,args,cache,url_to_code=item
+    if url1 in cache:
+        code1=cache[url1].copy()
+    else:
+        try:
+            code=' '.join(url_to_code[url1].split())
+        except:
+            code=""
+        code1=tokenizer.tokenize(code)
+    if url2 in cache:
+        code2=cache[url2].copy()
+    else:
+        try:
+            code=' '.join(url_to_code[url2].split())
+        except:
+            code=""
+        code2=tokenizer.tokenize(code)
+        
+    return convert_examples_to_features(code1,code2,label,url1,url2,tokenizer,args,cache)
+
+
+class InputFeatures(object):
+    """A single training/test features for a example."""
+    def __init__(self,
+                 input_tokens,
+                 input_ids,
+                 label,
+                 url1,
+                 url2
+
+    ):
+        self.input_tokens = input_tokens
+        self.input_ids = input_ids
+        self.label=label
+        self.url1=url1
+        self.url2=url2
+        
+def convert_examples_to_features(code1_tokens,code2_tokens,label,url1,url2,tokenizer,args,cache):
+    #source
+    code1_tokens=code1_tokens[:args.block_size-2]
+    code1_tokens =[tokenizer.cls_token]+code1_tokens+[tokenizer.sep_token]
+    code2_tokens=code2_tokens[:args.block_size-2]
+    code2_tokens =[tokenizer.cls_token]+code2_tokens+[tokenizer.sep_token]  
+    
+    code1_ids=tokenizer.convert_tokens_to_ids(code1_tokens)
+    padding_length = args.block_size - len(code1_ids)
+    code1_ids+=[tokenizer.pad_token_id]*padding_length
+    
+    code2_ids=tokenizer.convert_tokens_to_ids(code2_tokens)
+    padding_length = args.block_size - len(code2_ids)
+    code2_ids+=[tokenizer.pad_token_id]*padding_length
+    
+    source_tokens=code1_tokens+code2_tokens
+    source_ids=code1_ids+code2_ids
+    return InputFeatures(source_tokens,source_ids,label,url1,url2)
+
+class TextDataset(Dataset):
+    def __init__(self, tokenizer, args, file_path='train', block_size=512,pool=None):
+        postfix=file_path.split('/')[-1].split('.txt')[0]
+        self.examples = []
+        index_filename=file_path
+        logger.info("Creating features from index file at %s ", index_filename)
+        url_to_code={}
+        with open('/'.join(index_filename.split('/')[:-1])+'/data.jsonl') as f:
+            for line in f:
+                line=line.strip()
+                js=json.loads(line)
+                url_to_code[js['idx']]=js['func']
+
+        data=[]
+        cache={}
+        f=open(index_filename)
+        with open(index_filename) as f:
+            for line in f:
+                line=line.strip()
+                url1,url2,label=line.split('\t')
+                if url1 not in url_to_code or url2 not in url_to_code:
+                    continue
+                if label=='0':
+                    label=0
+                else:
+                    label=1
+                data.append((url1,url2,label,tokenizer, args,cache,url_to_code))
+        if 'test' not in postfix:
+            data=random.sample(data,int(len(data)*0.1))
+
+        self.examples=pool.map(get_example,tqdm(data,total=len(data)))
+        if 'train' in postfix:
+            for idx, example in enumerate(self.examples[:3]):
+                    logger.info("*** Example ***")
+                    logger.info("idx: {}".format(idx))
+                    logger.info("label: {}".format(example.label))
+                    logger.info("input_tokens: {}".format([x.replace('\u0120','_') for x in example.input_tokens]))
+                    logger.info("input_ids: {}".format(' '.join(map(str, example.input_ids))))
+
+
+
+    def __len__(self):
+        return len(self.examples)
+
+    def __getitem__(self, item):
+        
+        return torch.tensor(self.examples[item].input_ids),torch.tensor(self.examples[item].label)
+
+
+def load_and_cache_examples(args, tokenizer, evaluate=False,test=False,pool=None):
+    dataset = TextDataset(tokenizer, args, file_path=args.test_data_file if test else (args.eval_data_file if evaluate else args.train_data_file),block_size=args.block_size,pool=pool)
+    return dataset
+
+def set_seed(seed=42):
+    random.seed(seed)
+    os.environ['PYHTONHASHSEED'] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.backends.cudnn.deterministic = True
+
+def train(args, train_dataset, model, tokenizer,pool):
+    """ Train the model """
+
+    args.train_batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
+    train_sampler = RandomSampler(train_dataset) if args.local_rank == -1 else DistributedSampler(train_dataset)
+    
+    train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size)
+    args.max_steps=args.epoch*len( train_dataloader)
+    args.save_steps=len( train_dataloader)
+    args.warmup_steps=len( train_dataloader)
+    args.logging_steps=len( train_dataloader)
+    args.num_train_epochs=args.epoch
+    model.to(args.device)
+    # 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=args.max_steps)
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+
+    # multi-gpu training (should be after apex fp16 initialization)
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Distributed training (should be after apex fp16 initialization)
+    if args.local_rank != -1:
+        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank],
+                                                          output_device=args.local_rank,
+                                                          find_unused_parameters=True)
+
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    scheduler_last = os.path.join(checkpoint_last, 'scheduler.pt')
+    optimizer_last = os.path.join(checkpoint_last, 'optimizer.pt')
+    if os.path.exists(scheduler_last):
+        scheduler.load_state_dict(torch.load(scheduler_last))
+    if os.path.exists(optimizer_last):
+        optimizer.load_state_dict(torch.load(optimizer_last))
+    # Train!
+    logger.info("***** Running training *****")
+    logger.info("  Num examples = %d", len(train_dataset))
+    logger.info("  Num Epochs = %d", args.num_train_epochs)
+    logger.info("  Instantaneous batch size per GPU = %d", args.per_gpu_train_batch_size)
+    logger.info("  Total train batch size (w. parallel, distributed & accumulation) = %d",
+                args.train_batch_size * args.gradient_accumulation_steps * (
+                    torch.distributed.get_world_size() if args.local_rank != -1 else 1))
+    logger.info("  Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
+    logger.info("  Total optimization steps = %d", args.max_steps)
+    
+    global_step = args.start_step
+    tr_loss, logging_loss,avg_loss,tr_nb,tr_num,train_loss = 0.0, 0.0,0.0,0,0,0
+    best_mrr=0.0
+    best_f1=0
+    # model.resize_token_embeddings(len(tokenizer))
+    model.zero_grad()
+    set_seed(args.seed)  # Added here for reproducibility (even between python 2 and 3)
+ 
+    for idx in range(args.start_epoch, int(args.num_train_epochs)): 
+        bar = tqdm(train_dataloader,total=len(train_dataloader))
+        tr_num=0
+        train_loss=0
+        for step, batch in enumerate(bar):
+            inputs = batch[0].to(args.device)        
+            labels=batch[1].to(args.device) 
+            model.train()
+            loss,logits = model(inputs,labels)
+
+
+            if args.n_gpu > 1:
+                loss = loss.mean()  # mean() to average on multi-gpu parallel training
+            if args.gradient_accumulation_steps > 1:
+                loss = loss / args.gradient_accumulation_steps
+
+            if args.fp16:
+                with amp.scale_loss(loss, optimizer) as scaled_loss:
+                    scaled_loss.backward()
+                torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
+            else:
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+
+            tr_loss += loss.item()
+            tr_num+=1
+            train_loss+=loss.item()
+            if avg_loss==0:
+                avg_loss=tr_loss
+            avg_loss=round(train_loss/tr_num,5)
+            bar.set_description("epoch {} loss {}".format(idx,avg_loss))
+
+                
+            if (step + 1) % args.gradient_accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+                scheduler.step()  
+                global_step += 1
+                output_flag=True
+                avg_loss=round(np.exp((tr_loss - logging_loss) /(global_step- tr_nb)),4)
+                if args.local_rank in [-1, 0] and args.logging_steps > 0 and global_step % args.logging_steps == 0:
+                    logging_loss = tr_loss
+                    tr_nb=global_step
+
+                if args.local_rank in [-1, 0] and args.save_steps > 0 and global_step % args.save_steps == 0:
+                    
+                    if args.local_rank == -1 and args.evaluate_during_training:  # Only evaluate when single GPU otherwise metrics may not average well
+                        results = evaluate(args, model, tokenizer,pool=pool,eval_when_training=True)                 
+                        # Save model checkpoint
+
+                    if results['eval_f1']>best_f1:
+                        best_f1=results['eval_f1']
+                        logger.info("  "+"*"*20)  
+                        logger.info("  Best f1:%s",round(best_f1,4))
+                        logger.info("  "+"*"*20)                          
+                        
+                        checkpoint_prefix = 'checkpoint-best-f1'
+                        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))                        
+                        if not os.path.exists(output_dir):
+                            os.makedirs(output_dir)                        
+                        model_to_save = model.module if hasattr(model,'module') else model
+                        output_dir = os.path.join(output_dir, '{}'.format('model.bin')) 
+                        torch.save(model_to_save.state_dict(), output_dir)
+                        logger.info("Saving model checkpoint to %s", output_dir)
+                        
+        # 每一轮记录checkpoint
+        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)
+
+        if args.max_steps > 0 and global_step > args.max_steps:
+            train_iterator.close()
+            break
+    return global_step, tr_loss / global_step
+
+
+def evaluate(args, model, tokenizer, prefix="",pool=None,eval_when_training=False):
+    # Loop to handle MNLI double evaluation (matched, mis-matched)
+    eval_output_dir = args.output_dir
+    eval_dataset = load_and_cache_examples(args, tokenizer, evaluate=True,pool=pool)
+    if not os.path.exists(eval_output_dir) and args.local_rank in [-1, 0]:
+        os.makedirs(eval_output_dir)
+
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    # Note that DistributedSampler samples randomly
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size,num_workers=4,pin_memory=True)
+
+    # multi-gpu evaluate
+    if args.n_gpu > 1 and eval_when_training is False:
+        model = torch.nn.DataParallel(model)
+
+    # Eval!
+    logger.info("***** Running evaluation {} *****".format(prefix))
+    logger.info("  Num examples = %d", len(eval_dataset))
+    logger.info("  Batch size = %d", args.eval_batch_size)
+    eval_loss = 0.0
+    nb_eval_steps = 0
+    model.eval()
+    logits=[]  
+    y_trues=[]
+    for batch in eval_dataloader:
+        inputs = batch[0].to(args.device)        
+        labels=batch[1].to(args.device) 
+        with torch.no_grad():
+            lm_loss,logit = model(inputs,labels)
+            eval_loss += lm_loss.mean().item()
+            logits.append(logit.cpu().numpy())
+            y_trues.append(labels.cpu().numpy())
+        nb_eval_steps += 1
+    logits=np.concatenate(logits,0)
+    y_trues=np.concatenate(y_trues,0)
+    best_threshold=0
+    best_f1=0
+    for i in range(1,100):
+        threshold=i/100
+        y_preds=logits[:,1]>threshold
+        from sklearn.metrics import recall_score
+        recall=recall_score(y_trues, y_preds)
+        from sklearn.metrics import precision_score
+        precision=precision_score(y_trues, y_preds)   
+        from sklearn.metrics import f1_score
+        f1=f1_score(y_trues, y_preds) 
+        if f1>best_f1:
+            best_f1=f1
+            best_threshold=threshold
+
+    y_preds=logits[:,1]>best_threshold
+    from sklearn.metrics import recall_score
+    recall=recall_score(y_trues, y_preds)
+    from sklearn.metrics import precision_score
+    precision=precision_score(y_trues, y_preds)   
+    from sklearn.metrics import f1_score
+    f1=f1_score(y_trues, y_preds)             
+    result = {
+        "eval_recall": float(recall),
+        "eval_precision": float(precision),
+        "eval_f1": float(f1),
+        "eval_threshold":best_threshold,
+        
+    }
+
+    logger.info("***** Eval results {} *****".format(prefix))
+    for key in sorted(result.keys()):
+        logger.info("  %s = %s", key, str(round(result[key],4)))
+
+    return result
+
+def test(args, model, tokenizer, prefix="",pool=None,best_threshold=0):
+    # Loop to handle MNLI double evaluation (matched, mis-matched)
+    eval_dataset = load_and_cache_examples(args, tokenizer, test=True,pool=pool)
+
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    # Note that DistributedSampler samples randomly
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size,num_workers=4,pin_memory=True)
+
+    # multi-gpu evaluate
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Eval!
+    logger.info("***** Running Test {} *****".format(prefix))
+    logger.info("  Num examples = %d", len(eval_dataset))
+    logger.info("  Batch size = %d", args.eval_batch_size)
+    eval_loss = 0.0
+    nb_eval_steps = 0
+    model.eval()
+    logits=[]  
+    y_trues=[]
+    for batch in eval_dataloader:
+        inputs = batch[0].to(args.device)        
+        labels=batch[1].to(args.device) 
+        with torch.no_grad():
+            lm_loss,logit = model(inputs,labels)
+            eval_loss += lm_loss.mean().item()
+            logits.append(logit.cpu().numpy())
+            y_trues.append(labels.cpu().numpy())
+        nb_eval_steps += 1
+    logits=np.concatenate(logits,0)
+    y_preds=logits[:,1]>best_threshold
+    with open(os.path.join(args.output_dir,"predictions.txt"),'w') as f:
+        for example,pred in zip(eval_dataset.examples,y_preds):
+            if pred:
+                f.write(example.url1+'\t'+example.url2+'\t'+'1'+'\n')
+            else:
+                f.write(example.url1+'\t'+example.url2+'\t'+'0'+'\n')
+                                                
+def main():
+    parser = argparse.ArgumentParser()
+
+    ## Required parameters
+    parser.add_argument("--train_data_file", default=None, type=str, required=True,
+                        help="The input training data file (a text file).")
+    parser.add_argument("--output_dir", default=None, type=str, required=True,
+                        help="The output directory where the model predictions and checkpoints will be written.")
+
+    ## Other parameters
+    parser.add_argument("--eval_data_file", default=None, type=str,
+                        help="An optional input evaluation data file to evaluate the perplexity on (a text file).")
+    parser.add_argument("--test_data_file", default=None, type=str,
+                        help="An optional input evaluation data file to evaluate the perplexity on (a text file).")
+                    
+    parser.add_argument("--model_type", default="bert", type=str,
+                        help="The model architecture to be fine-tuned.")
+    parser.add_argument("--model_name_or_path", default=None, type=str,
+                        help="The model checkpoint for weights initialization.")
+
+    parser.add_argument("--mlm", action='store_true',
+                        help="Train with masked-language modeling loss instead of language modeling.")
+    parser.add_argument("--mlm_probability", type=float, default=0.15,
+                        help="Ratio of tokens to mask for masked language modeling loss")
+
+    parser.add_argument("--config_name", default="", type=str,
+                        help="Optional pretrained config name or path if not the same as model_name_or_path")
+    parser.add_argument("--tokenizer_name", default="", type=str,
+                        help="Optional pretrained tokenizer name or path if not the same as model_name_or_path")
+    parser.add_argument("--cache_dir", default="", type=str,
+                        help="Optional directory to store the pre-trained models downloaded from s3 (instread of the default one)")
+    parser.add_argument("--block_size", default=-1, type=int,
+                        help="Optional input sequence length after tokenization."
+                             "The training dataset will be truncated in block of this size for training."
+                             "Default to the model max input length for single sentence inputs (take into account special tokens).")
+    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("--evaluate_during_training", action='store_true',
+                        help="Run evaluation during training at each logging step.")
+    parser.add_argument("--do_lower_case", action='store_true',
+                        help="Set this flag if you are using an uncased model.")
+
+    parser.add_argument("--train_batch_size", default=4, type=int,
+                        help="Batch size per GPU/CPU for training.")
+    parser.add_argument("--eval_batch_size", default=4, 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("--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=1.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("--warmup_steps", default=0, type=int,
+                        help="Linear warmup over warmup_steps.")
+
+    parser.add_argument('--logging_steps', type=int, default=50,
+                        help="Log every X updates steps.")
+    parser.add_argument('--save_steps', type=int, default=50,
+                        help="Save checkpoint every X updates steps.")
+    parser.add_argument('--save_total_limit', type=int, default=None,
+                        help='Limit the total amount of checkpoints, delete the older checkpoints in the output_dir, does not delete by default')
+    parser.add_argument("--eval_all_checkpoints", action='store_true',
+                        help="Evaluate all checkpoints starting with the same prefix as model_name_or_path ending and ending with step number")
+    parser.add_argument("--no_cuda", action='store_true',
+                        help="Avoid using CUDA when available")
+    parser.add_argument('--overwrite_output_dir', action='store_true',
+                        help="Overwrite the content of the output directory")
+    parser.add_argument('--overwrite_cache', action='store_true',
+                        help="Overwrite the cached training and evaluation sets")
+    parser.add_argument('--seed', type=int, default=42,
+                        help="random seed for initialization")
+    parser.add_argument('--epoch', type=int, default=42,
+                        help="random seed for initialization")
+    parser.add_argument('--fp16', action='store_true',
+                        help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit")
+    parser.add_argument('--fp16_opt_level', type=str, default='O1',
+                        help="For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
+                             "See details at https://nvidia.github.io/apex/amp.html")
+    parser.add_argument("--local_rank", type=int, default=-1,
+                        help="For distributed training: local_rank")
+    parser.add_argument('--server_ip', type=str, default='', help="For distant debugging.")
+    parser.add_argument('--server_port', type=str, default='', help="For distant debugging.")
+
+    
+    pool = multiprocessing.Pool(cpu_cont)
+    args = parser.parse_args()
+
+    # Setup distant debugging if needed
+    if args.server_ip and args.server_port:
+        # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
+        import ptvsd
+        print("Waiting for debugger attach")
+        ptvsd.enable_attach(address=(args.server_ip, args.server_port), redirect_output=True)
+        ptvsd.wait_for_attach()
+
+    # 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
+    args.device = device
+    args.per_gpu_train_batch_size=args.train_batch_size//args.n_gpu
+    args.per_gpu_eval_batch_size=args.eval_batch_size//args.n_gpu
+    # Setup logging
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s -   %(message)s',
+                        datefmt='%m/%d/%Y %H:%M:%S',
+                        level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN)
+    logger.warning("Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
+                   args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.fp16)
+
+    # Set seed
+    set_seed(args.seed)
+
+    # Load pretrained model and tokenizer
+    if args.local_rank not in [-1, 0]:
+        torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training download model & vocab
+
+    args.start_epoch = 0
+    args.start_step = 0
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    if os.path.exists(checkpoint_last) and os.listdir(checkpoint_last):
+        args.model_name_or_path = os.path.join(checkpoint_last, 'pytorch_model.bin')
+        args.config_name = os.path.join(checkpoint_last, 'config.json')
+        idx_file = os.path.join(checkpoint_last, 'idx_file.txt')
+        with open(idx_file, encoding='utf-8') as idxf:
+            args.start_epoch = int(idxf.readlines()[0].strip()) + 1
+
+        step_file = os.path.join(checkpoint_last, 'step_file.txt')
+        if os.path.exists(step_file):
+            with open(step_file, encoding='utf-8') as stepf:
+                args.start_step = int(stepf.readlines()[0].strip())
+
+        logger.info("reload model from {}, resume from {} epoch".format(checkpoint_last, args.start_epoch))
+
+    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,
+                                          cache_dir=args.cache_dir if args.cache_dir else None)
+    config.num_labels=2
+    tokenizer = tokenizer_class.from_pretrained(args.tokenizer_name,
+                                                do_lower_case=args.do_lower_case,
+                                                cache_dir=args.cache_dir if args.cache_dir else None)
+    if args.block_size <= 0:
+        args.block_size = tokenizer.max_len_single_sentence  # Our input block size will be the max possible for the model
+    args.block_size = min(args.block_size, tokenizer.max_len_single_sentence)
+    if args.model_name_or_path:
+        model = model_class.from_pretrained(args.model_name_or_path,
+                                            from_tf=bool('.ckpt' in args.model_name_or_path),
+                                            config=config,
+                                            cache_dir=args.cache_dir if args.cache_dir else None)    
+    else:
+        model = model_class(config)
+
+    model=Model(model,config,tokenizer,args)
+    if args.local_rank == 0:
+        torch.distributed.barrier()  # End of barrier to make sure only the first process in distributed training download model & vocab
+
+    logger.info("Training/evaluation parameters %s", args)
+
+    # Training
+    if args.do_train:
+        if args.local_rank not in [-1, 0]:
+            torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training process the dataset, and the others will use the cache
+
+        train_dataset = load_and_cache_examples(args, tokenizer, evaluate=False,pool=pool)
+
+        if args.local_rank == 0:
+            torch.distributed.barrier()
+
+        global_step, tr_loss = train(args, train_dataset, model, tokenizer,pool)
+
+
+    # Evaluation
+    results = {}
+    if args.do_eval and args.local_rank in [-1, 0]:
+        checkpoint_prefix = 'epoch_2/subject_model.pth'
+        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))  
+        model.load_state_dict(torch.load(output_dir))
+        model.to(args.device)
+        result=evaluate(args, model, tokenizer,pool=pool)
+        
+    if args.do_test and args.local_rank in [-1, 0]:
+        checkpoint_prefix = 'epoch_2/subject_model.pth'
+        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))  
+        model.load_state_dict(torch.load(output_dir))
+        model.to(args.device)
+        test(args, model, tokenizer,pool=pool,best_threshold=0.5)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()
+

Code-Code/Clone-detection-BigCloneBench/code/train.sh

@@ -0,0 +1,18 @@
+CUDA_VISIBLE_DEVICES=0,1 python run.py \
+    --output_dir=../model \
+    --model_type=roberta \
+    --config_name=microsoft/codebert-base \
+    --model_name_or_path=microsoft/codebert-base \
+    --tokenizer_name=roberta-base \
+    --do_train \
+    --train_data_file=../dataset/train.txt \
+    --eval_data_file=../dataset/valid.txt \
+    --test_data_file=../dataset/test.txt \
+    --epoch 2 \
+    --block_size 400 \
+    --train_batch_size 16 \
+    --eval_batch_size 32 \
+    --learning_rate 5e-5 \
+    --max_grad_norm 1.0 \
+    --evaluate_during_training \
+    --seed 123456

Code-Code/Clone-detection-BigCloneBench/dataset.zip

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

Code-Code/Clone-detection-BigCloneBench/model/epoch_1/subject_model.pth

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

Code-Code/Clone-detection-BigCloneBench/model/epoch_2/subject_model.pth

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

Code-Code/Clone-detection-POJ-104/code/eval.sh

@@ -0,0 +1,17 @@
+CUDA_VISIBLE_DEVICES=0,1  python run.py \
+    --output_dir=../model \
+    --model_type=roberta \
+    --config_name=microsoft/codebert-base \
+    --model_name_or_path=microsoft/codebert-base \
+    --tokenizer_name=roberta-base \
+    --do_eval \
+    --train_data_file=../dataset/train.jsonl \
+    --eval_data_file=../dataset/valid.jsonl \
+    --epoch 2 \
+    --block_size 400 \
+    --train_batch_size 8 \
+    --eval_batch_size 16 \
+    --learning_rate 2e-5 \
+    --max_grad_norm 1.0 \
+    --evaluate_during_training \
+    --seed 123456

Code-Code/Clone-detection-POJ-104/code/evaluate.sh

@@ -0,0 +1,6 @@
+python extract_answers.py \
+    -c ../dataset/valid.jsonl \
+    -o ../model/answers.jsonl 
+python evaluator.py \
+    -a ../model/answers.jsonl  \
+    -p ../model/predictions.jsonl 

Code-Code/Clone-detection-POJ-104/code/evaluator.py

@@ -0,0 +1,64 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+import logging
+import sys,json
+import numpy as np
+from tqdm import tqdm
+
+def read_answers(filename):
+    answers={}
+    with open(filename) as f:
+        for line in f:
+            line=line.strip()
+            js=json.loads(line)
+            answers[js['index']]=js['answers']
+    return answers
+
+def read_predictions(filename):
+    predictions={}
+    with open(filename) as f:
+        for line in f:
+            line=line.strip()
+            js=json.loads(line)
+            predictions[js['index']]=js['answers']
+    return predictions
+
+def calculate_scores(answers,predictions):
+    scores=[]
+    for key in answers:
+        if key not in predictions:
+            logging.error("Missing prediction for index {}.".format(key))
+            sys.exit()
+            
+        if len(answers[key])!=len(predictions[key]):
+            logging.error("Mismatch the number of answers for index {}.".format(key))
+            sys.exit()
+                
+        answer = set(answers[key])   
+
+        Avep = []
+        for k, p in enumerate(predictions[key]):
+            if p in answer:
+                Avep.append((len(Avep)+1)/(k+1))
+
+        scores.append(sum(Avep)/len(answer))
+
+    result={}
+    result['MAP@R']= round(np.mean(scores),4)
+    return result
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Evaluate leaderboard predictions for POJ-104 dataset.')
+    parser.add_argument('--answers', '-a',help="filename of the labels, in txt format.")
+    parser.add_argument('--predictions', '-p',help="filename of the leaderboard predictions, in txt format.")
+    
+
+    args = parser.parse_args()
+    answers=read_answers(args.answers)
+    predictions=read_predictions(args.predictions)
+    scores=calculate_scores(answers,predictions)
+    print(scores)
+
+if __name__ == '__main__':
+    main()

Code-Code/Clone-detection-POJ-104/code/extract_answers.py

@@ -0,0 +1,39 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+import json
+
+def extract_answers(filename):
+	cluster={}
+	with open(filename) as f:
+		for line in f:
+			line=line.strip()
+			js=json.loads(line)
+			if js['label'] not in cluster:
+				cluster[js['label']]=set()
+			cluster[js['label']].add(js['index'])
+	answers=[]
+	for key in cluster:
+		for idx1 in cluster[key]:
+			temp={}
+			temp['index']=idx1
+			temp['answers']=[]
+			for idx2 in cluster[key]:
+				if idx1!=idx2:
+					temp['answers'].append(idx2)
+			answers.append(temp)
+	return answers
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Extract answers from code files.')
+    parser.add_argument('--codefile', '-c',help="filename of the code examples.")
+    parser.add_argument('--outfile', '-o',help="filename of output.")
+    args = parser.parse_args()
+    answers=extract_answers(args.codefile)
+    with open(args.outfile,'w') as f:
+    	for line in answers:
+    		f.write(json.dumps(line)+'\n')
+
+if __name__ == '__main__':
+    main()

Code-Code/Clone-detection-POJ-104/code/model.py

@@ -0,0 +1,48 @@
+# 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
+import torch.nn.functional as F
+from torch.nn import CrossEntropyLoss, MSELoss
+
+
+    
+class Model(nn.Module):   
+    def __init__(self, encoder,config,tokenizer,args):
+        super(Model, self).__init__()
+        self.encoder = encoder
+        self.config=config
+        self.tokenizer=tokenizer
+        self.args=args
+    
+        
+    def forward(self, input_ids=None,p_input_ids=None,n_input_ids=None,labels=None): 
+        bs,_=input_ids.size()
+        input_ids=torch.cat((input_ids,p_input_ids,n_input_ids),0)
+        
+        outputs=self.encoder(input_ids,attention_mask=input_ids.ne(1))
+        if len(outputs) > 1:
+            outputs = outputs[1]
+        else:
+            outputs = outputs[0][:, 0, :]
+        outputs=outputs.split(bs,0)
+        
+        prob_1=(outputs[0]*outputs[1]).sum(-1)
+        prob_2=(outputs[0]*outputs[2]).sum(-1)
+        temp=torch.cat((outputs[0],outputs[1]),0)
+        temp_labels=torch.cat((labels,labels),0)
+        prob_3= torch.mm(outputs[0],temp.t())
+        mask=labels[:,None]==temp_labels[None,:]
+        prob_3=prob_3*(1-mask.float())-1e9*mask.float()
+        
+        prob=torch.softmax(torch.cat((prob_1[:,None],prob_2[:,None],prob_3),-1),-1)
+        loss=torch.log(prob[:,0]+1e-10)
+        loss=-loss.mean()
+        return loss,outputs[0]
+
+      
+        
+ 

Code-Code/Clone-detection-POJ-104/code/run.py

@@ -0,0 +1,632 @@
+# 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, division, print_function
+
+import argparse
+import glob
+import logging
+import os
+import pickle
+import random
+import re
+import shutil
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Dataset, SequentialSampler, RandomSampler,TensorDataset
+from torch.utils.data.distributed import DistributedSampler
+import json
+try:
+    from torch.utils.tensorboard import SummaryWriter
+except:
+    from tensorboardX import SummaryWriter
+
+from tqdm import tqdm, trange
+import multiprocessing
+from model import Model
+cpu_cont = multiprocessing.cpu_count()
+from transformers import (WEIGHTS_NAME, AdamW, get_linear_schedule_with_warmup,
+                          BertConfig, BertModel, BertTokenizer,
+                          GPT2Config, GPT2LMHeadModel, GPT2Tokenizer,
+                          OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer,
+                          RobertaConfig, RobertaModel, RobertaTokenizer,
+                          DistilBertConfig, DistilBertModel, DistilBertTokenizer)
+
+logger = logging.getLogger(__name__)
+
+MODEL_CLASSES = {
+    'gpt2': (GPT2Config, GPT2LMHeadModel, GPT2Tokenizer),
+    'openai-gpt': (OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
+    'bert': (BertConfig, BertModel, BertTokenizer),
+    'roberta': (RobertaConfig, RobertaModel, RobertaTokenizer),
+    'distilbert': (DistilBertConfig, DistilBertModel, DistilBertTokenizer)
+}
+
+
+class InputFeatures(object):
+    """A single training/test features for a example."""
+    def __init__(self,
+                 input_tokens,
+                 input_ids,
+                 index,
+                 label,
+
+    ):
+        self.input_tokens = input_tokens
+        self.input_ids = input_ids
+        self.index=index
+        self.label=label
+
+        
+def convert_examples_to_features(js,tokenizer,args):
+    #source
+    code=' '.join(js['code'].split())
+    code_tokens=tokenizer.tokenize(code)[:args.block_size-2]
+    source_tokens =[tokenizer.cls_token]+code_tokens+[tokenizer.sep_token]
+    source_ids =  tokenizer.convert_tokens_to_ids(source_tokens)
+    padding_length = args.block_size - len(source_ids)
+    source_ids+=[tokenizer.pad_token_id]*padding_length
+    return InputFeatures(source_tokens,source_ids,js['index'],int(js['label']))
+
+class TextDataset(Dataset):
+    def __init__(self, tokenizer, args, file_path=None):
+        self.examples = []
+        data=[]
+        with open(file_path) as f:
+            for line in f:
+                line=line.strip()
+                js=json.loads(line)
+                data.append(js)
+        for js in data:
+            self.examples.append(convert_examples_to_features(js,tokenizer,args))
+        if 'train' in file_path:
+            for idx, example in enumerate(self.examples[:3]):
+                    logger.info("*** Example ***")
+                    logger.info("idx: {}".format(idx))
+                    logger.info("label: {}".format(example.label))
+                    logger.info("input_tokens: {}".format([x.replace('\u0120','_') for x in example.input_tokens]))
+                    logger.info("input_ids: {}".format(' '.join(map(str, example.input_ids))))
+        self.label_examples={}
+        for e in self.examples:
+            if e.label not in self.label_examples:
+                self.label_examples[e.label]=[]
+            self.label_examples[e.label].append(e)
+        
+    def __len__(self):
+        return len(self.examples)
+
+    def __getitem__(self, i):   
+        label=self.examples[i].label
+        index=self.examples[i].index
+        labels=list(self.label_examples)
+        labels.remove(label)
+        while True:
+            shuffle_example=random.sample(self.label_examples[label],1)[0]
+            if shuffle_example.index!=index:
+                p_example=shuffle_example
+                break
+        n_example=random.sample(self.label_examples[random.sample(labels,1)[0]],1)[0]
+        
+        return (torch.tensor(self.examples[i].input_ids),torch.tensor(p_example.input_ids),
+                torch.tensor(n_example.input_ids),torch.tensor(label))
+            
+
+def set_seed(seed=42):
+    random.seed(seed)
+    os.environ['PYHTONHASHSEED'] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.backends.cudnn.deterministic = True
+
+
+def train(args, train_dataset, model, tokenizer):
+    """ Train the model """
+    
+    args.train_batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
+    train_sampler = RandomSampler(train_dataset) if args.local_rank == -1 else DistributedSampler(train_dataset)
+    
+    train_dataloader = DataLoader(train_dataset, sampler=train_sampler, 
+                                  batch_size=args.train_batch_size,num_workers=4,pin_memory=True)
+    args.max_steps=args.epoch*len( train_dataloader)
+    args.save_steps=len( train_dataloader)
+    args.warmup_steps=len( train_dataloader)
+    args.logging_steps=len( train_dataloader)
+    args.num_train_epochs=args.epoch
+    model.to(args.device)
+    # 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.max_steps*0.1,
+                                                num_training_steps=args.max_steps)
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+
+    # multi-gpu training (should be after apex fp16 initialization)
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Distributed training (should be after apex fp16 initialization)
+    if args.local_rank != -1:
+        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank],
+                                                          output_device=args.local_rank,
+                                                          find_unused_parameters=True)
+
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    scheduler_last = os.path.join(checkpoint_last, 'scheduler.pt')
+    optimizer_last = os.path.join(checkpoint_last, 'optimizer.pt')
+    if os.path.exists(scheduler_last):
+        scheduler.load_state_dict(torch.load(scheduler_last))
+    if os.path.exists(optimizer_last):
+        optimizer.load_state_dict(torch.load(optimizer_last))
+    # Train!
+    logger.info("***** Running training *****")
+    logger.info("  Num examples = %d", len(train_dataset))
+    logger.info("  Num Epochs = %d", args.num_train_epochs)
+    logger.info("  Instantaneous batch size per GPU = %d", args.per_gpu_train_batch_size)
+    logger.info("  Total train batch size (w. parallel, distributed & accumulation) = %d",
+                args.train_batch_size * args.gradient_accumulation_steps * (
+                    torch.distributed.get_world_size() if args.local_rank != -1 else 1))
+    logger.info("  Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
+    logger.info("  Total optimization steps = %d", args.max_steps)
+    
+    global_step = args.start_step
+    tr_loss, logging_loss,avg_loss,tr_nb,tr_num,train_loss = 0.0, 0.0,0.0,0,0,0
+    best_acc=0.0
+    # model.resize_token_embeddings(len(tokenizer))
+    model.zero_grad()
+    for idx in range(args.start_epoch, int(args.num_train_epochs)): 
+        bar = train_dataloader
+        tr_num=0
+        train_loss=0
+        for step, batch in enumerate(bar):
+            inputs = batch[0].to(args.device)    
+            p_inputs = batch[1].to(args.device)
+            n_inputs = batch[2].to(args.device)
+            labels = batch[3].to(args.device)
+            model.train()
+            loss,vec = model(inputs,p_inputs,n_inputs,labels)
+
+
+            if args.n_gpu > 1:
+                loss = loss.mean()  # mean() to average on multi-gpu parallel training
+            if args.gradient_accumulation_steps > 1:
+                loss = loss / args.gradient_accumulation_steps
+
+            if args.fp16:
+                with amp.scale_loss(loss, optimizer) as scaled_loss:
+                    scaled_loss.backward()
+                torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
+            else:
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+
+            tr_loss += loss.item()
+            tr_num+=1
+            train_loss+=loss.item()
+            if avg_loss==0:
+                avg_loss=tr_loss
+            avg_loss=round(train_loss/tr_num,5)
+            if (step+1)% 100==0:
+                logger.info("epoch {} step {} loss {}".format(idx,step+1,avg_loss))
+            #bar.set_description("epoch {} loss {}".format(idx,avg_loss))
+
+                
+            if (step + 1) % args.gradient_accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+                scheduler.step()  
+                global_step += 1
+                output_flag=True
+                avg_loss=round(np.exp((tr_loss - logging_loss) /(global_step- tr_nb)),4)
+                if args.local_rank in [-1, 0] and args.logging_steps > 0 and global_step % args.logging_steps == 0:
+                    logging_loss = tr_loss
+                    tr_nb=global_step
+
+                if args.local_rank in [-1, 0] and args.save_steps > 0 and global_step % args.save_steps == 0:
+                    
+                    if args.local_rank == -1 and args.evaluate_during_training:  # Only evaluate when single GPU otherwise metrics may not average well
+                        results = evaluate(args, model, tokenizer,eval_when_training=True)
+                        for key, value in results.items():
+                            logger.info("  %s = %s", key, round(value,4))                    
+                        # Save model checkpoint
+                        tr_num=0
+                        train_loss=0
+ 
+                    if results['eval_map']>best_acc:
+                        best_acc=results['eval_map']
+                        logger.info("  "+"*"*20)  
+                        logger.info("  Best map:%s",round(best_acc,4))
+                        logger.info("  "+"*"*20)                          
+                        
+                        checkpoint_prefix = 'checkpoint-best-map'
+                        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))                        
+                        if not os.path.exists(output_dir):
+                            os.makedirs(output_dir)                        
+                        model_to_save = model.module if hasattr(model,'module') else model
+                        output_dir = os.path.join(output_dir, '{}'.format('model.bin'))   
+                        torch.save(model_to_save.state_dict(), output_dir)
+                        logger.info("Saving model checkpoint to %s", output_dir)
+
+        # 每一轮记录checkpoint
+        output_dir = os.path.join(args.output_dir, 'epoch_{}'.format(idx))
+        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)
+
+
+eval_dataset=None
+def evaluate(args, model, tokenizer,eval_when_training=False):
+    # Loop to handle MNLI double evaluation (matched, mis-matched)
+    eval_output_dir = args.output_dir
+    global eval_dataset
+    if eval_dataset is None:
+        eval_dataset = TextDataset(tokenizer, args,args.eval_data_file)
+
+    if not os.path.exists(eval_output_dir) and args.local_rank in [-1, 0]:
+        os.makedirs(eval_output_dir)
+
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    # Note that DistributedSampler samples randomly
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size,num_workers=4,pin_memory=True)
+
+    # multi-gpu evaluate
+    if args.n_gpu > 1 and eval_when_training is False:
+        model = torch.nn.DataParallel(model)
+
+    # Eval!
+    logger.info("***** Running evaluation *****")
+    logger.info("  Num examples = %d", len(eval_dataset))
+    logger.info("  Batch size = %d", args.eval_batch_size)
+    eval_loss = 0.0
+    nb_eval_steps = 0
+    model.eval()
+    vecs=[] 
+    labels=[]
+    for batch in eval_dataloader:
+        inputs = batch[0].to(args.device)    
+        p_inputs = batch[1].to(args.device)
+        n_inputs = batch[2].to(args.device)
+        label = batch[3].to(args.device)
+        with torch.no_grad():
+            lm_loss,vec = model(inputs,p_inputs,n_inputs,label)
+            eval_loss += lm_loss.mean().item()
+            vecs.append(vec.cpu().numpy())
+            labels.append(label.cpu().numpy())
+        nb_eval_steps += 1
+    vecs=np.concatenate(vecs,0)
+    labels=np.concatenate(labels,0)
+    eval_loss = eval_loss / nb_eval_steps
+    perplexity = torch.tensor(eval_loss)
+
+    scores=np.matmul(vecs,vecs.T)
+    dic={}
+    for i in range(scores.shape[0]):
+        scores[i,i]=-1000000
+        if int(labels[i]) not in dic:
+            dic[int(labels[i])]=-1
+        dic[int(labels[i])]+=1
+    sort_ids=np.argsort(scores, axis=-1, kind='quicksort', order=None)[:,::-1]
+    MAP=[]
+    for i in range(scores.shape[0]):
+        cont=0
+        label=int(labels[i])
+        Avep = []
+        for j in range(dic[label]):
+            index=sort_ids[i,j]
+            if int(labels[index])==label:
+                Avep.append((len(Avep)+1)/(j+1))
+        MAP.append(sum(Avep)/dic[label])
+          
+    result = {
+        "eval_loss": float(perplexity),
+        "eval_map":float(np.mean(MAP))
+    }
+
+
+    return result
+
+def test(args, model, tokenizer):
+    # Loop to handle MNLI double evaluation (matched, mis-matched)
+    eval_dataset = TextDataset(tokenizer, args,args.test_data_file)
+
+
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    # Note that DistributedSampler samples randomly
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size)
+
+    # multi-gpu evaluate
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Eval!
+    logger.info("***** Running Test *****")
+    logger.info("  Num examples = %d", len(eval_dataset))
+    logger.info("  Batch size = %d", args.eval_batch_size)
+    eval_loss = 0.0
+    nb_eval_steps = 0
+    model.eval()
+    vecs=[] 
+    labels=[]
+    for batch in eval_dataloader:
+        inputs = batch[0].to(args.device)    
+        p_inputs = batch[1].to(args.device)
+        n_inputs = batch[2].to(args.device)
+        label = batch[3].to(args.device)
+        with torch.no_grad():
+            lm_loss,vec = model(inputs,p_inputs,n_inputs,label)
+            eval_loss += lm_loss.mean().item()
+            vecs.append(vec.cpu().numpy())
+            labels.append(label.cpu().numpy())
+        nb_eval_steps += 1
+    vecs=np.concatenate(vecs,0)
+    labels=np.concatenate(labels,0)
+    eval_loss = eval_loss / nb_eval_steps
+    perplexity = torch.tensor(eval_loss)
+
+    scores=np.matmul(vecs,vecs.T)
+    for i in range(scores.shape[0]):
+        scores[i,i]=-1000000
+    sort_ids=np.argsort(scores, axis=-1, kind='quicksort', order=None)[:,::-1]
+    indexs=[]
+    for example in eval_dataset.examples:
+        indexs.append(example.index)
+    with open(os.path.join(args.output_dir,"predictions.jsonl"),'w') as f:
+        for index,sort_id in zip(indexs,sort_ids):
+            js={}
+            js['index']=index
+            js['answers']=[]
+            for idx in sort_id[:499]:
+                js['answers'].append(indexs[int(idx)])
+            f.write(json.dumps(js)+'\n')
+
+                        
+                        
+def main():
+    parser = argparse.ArgumentParser()
+
+    ## Required parameters
+    parser.add_argument("--train_data_file", default=None, type=str, required=True,
+                        help="The input training data file (a text file).")
+    parser.add_argument("--output_dir", default=None, type=str, required=True,
+                        help="The output directory where the model predictions and checkpoints will be written.")
+
+    ## Other parameters
+    parser.add_argument("--eval_data_file", default=None, type=str,
+                        help="An optional input evaluation data file to evaluate the perplexity on (a text file).")
+    parser.add_argument("--test_data_file", default=None, type=str,
+                        help="An optional input evaluation data file to evaluate the perplexity on (a text file).")
+                    
+    parser.add_argument("--model_type", default="bert", type=str,
+                        help="The model architecture to be fine-tuned.")
+    parser.add_argument("--model_name_or_path", default=None, type=str,
+                        help="The model checkpoint for weights initialization.")
+
+    parser.add_argument("--mlm", action='store_true',
+                        help="Train with masked-language modeling loss instead of language modeling.")
+    parser.add_argument("--mlm_probability", type=float, default=0.15,
+                        help="Ratio of tokens to mask for masked language modeling loss")
+
+    parser.add_argument("--config_name", default="", type=str,
+                        help="Optional pretrained config name or path if not the same as model_name_or_path")
+    parser.add_argument("--tokenizer_name", default="", type=str,
+                        help="Optional pretrained tokenizer name or path if not the same as model_name_or_path")
+    parser.add_argument("--cache_dir", default="", type=str,
+                        help="Optional directory to store the pre-trained models downloaded from s3 (instread of the default one)")
+    parser.add_argument("--block_size", default=-1, type=int,
+                        help="Optional input sequence length after tokenization."
+                             "The training dataset will be truncated in block of this size for training."
+                             "Default to the model max input length for single sentence inputs (take into account special tokens).")
+    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("--evaluate_during_training", action='store_true',
+                        help="Run evaluation during training at each logging step.")
+    parser.add_argument("--do_lower_case", action='store_true',
+                        help="Set this flag if you are using an uncased model.")
+
+    parser.add_argument("--train_batch_size", default=4, type=int,
+                        help="Batch size per GPU/CPU for training.")
+    parser.add_argument("--eval_batch_size", default=4, 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("--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=1.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("--warmup_steps", default=0, type=int,
+                        help="Linear warmup over warmup_steps.")
+
+    parser.add_argument('--logging_steps', type=int, default=50,
+                        help="Log every X updates steps.")
+    parser.add_argument('--save_steps', type=int, default=50,
+                        help="Save checkpoint every X updates steps.")
+    parser.add_argument('--save_total_limit', type=int, default=None,
+                        help='Limit the total amount of checkpoints, delete the older checkpoints in the output_dir, does not delete by default')
+    parser.add_argument("--eval_all_checkpoints", action='store_true',
+                        help="Evaluate all checkpoints starting with the same prefix as model_name_or_path ending and ending with step number")
+    parser.add_argument("--no_cuda", action='store_true',
+                        help="Avoid using CUDA when available")
+    parser.add_argument('--overwrite_output_dir', action='store_true',
+                        help="Overwrite the content of the output directory")
+    parser.add_argument('--overwrite_cache', action='store_true',
+                        help="Overwrite the cached training and evaluation sets")
+    parser.add_argument('--seed', type=int, default=42,
+                        help="random seed for initialization")
+    parser.add_argument('--epoch', type=int, default=42,
+                        help="random seed for initialization")
+    parser.add_argument('--fp16', action='store_true',
+                        help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit")
+    parser.add_argument('--fp16_opt_level', type=str, default='O1',
+                        help="For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
+                             "See details at https://nvidia.github.io/apex/amp.html")
+    parser.add_argument("--local_rank", type=int, default=-1,
+                        help="For distributed training: local_rank")
+    parser.add_argument('--server_ip', type=str, default='', help="For distant debugging.")
+    parser.add_argument('--server_port', type=str, default='', help="For distant debugging.")
+    
+
+    args = parser.parse_args()
+
+
+    # Setup distant debugging if needed
+    if args.server_ip and args.server_port:
+        # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
+        import ptvsd
+        print("Waiting for debugger attach")
+        ptvsd.enable_attach(address=(args.server_ip, args.server_port), redirect_output=True)
+        ptvsd.wait_for_attach()
+
+    # 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
+    args.device = device
+    args.per_gpu_train_batch_size=args.train_batch_size//args.n_gpu
+    args.per_gpu_eval_batch_size=args.eval_batch_size//args.n_gpu
+    # Setup logging
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s -   %(message)s',
+                        datefmt='%m/%d/%Y %H:%M:%S',
+                        level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN)
+    logger.warning("Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
+                   args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.fp16)
+
+
+    # Set seed
+    set_seed(args.seed)
+
+    # Load pretrained model and tokenizer
+    if args.local_rank not in [-1, 0]:
+        torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training download model & vocab
+
+    args.start_epoch = 0
+    args.start_step = 0
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    if os.path.exists(checkpoint_last) and os.listdir(checkpoint_last):
+        args.model_name_or_path = os.path.join(checkpoint_last, 'pytorch_model.bin')
+        args.config_name = os.path.join(checkpoint_last, 'config.json')
+        idx_file = os.path.join(checkpoint_last, 'idx_file.txt')
+        with open(idx_file, encoding='utf-8') as idxf:
+            args.start_epoch = int(idxf.readlines()[0].strip()) + 1
+
+        step_file = os.path.join(checkpoint_last, 'step_file.txt')
+        if os.path.exists(step_file):
+            with open(step_file, encoding='utf-8') as stepf:
+                args.start_step = int(stepf.readlines()[0].strip())
+
+        logger.info("reload model from {}, resume from {} epoch".format(checkpoint_last, args.start_epoch))
+
+    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,
+                                          cache_dir=args.cache_dir if args.cache_dir else None)
+    config.num_labels=1
+    tokenizer = tokenizer_class.from_pretrained(args.tokenizer_name,
+                                                do_lower_case=args.do_lower_case,
+                                                cache_dir=args.cache_dir if args.cache_dir else None)
+    if args.block_size <= 0:
+        args.block_size = tokenizer.max_len_single_sentence  # Our input block size will be the max possible for the model
+    args.block_size = min(args.block_size, tokenizer.max_len_single_sentence)
+    if args.model_name_or_path:
+        model = model_class.from_pretrained(args.model_name_or_path,
+                                            from_tf=bool('.ckpt' in args.model_name_or_path),
+                                            config=config,
+                                            cache_dir=args.cache_dir if args.cache_dir else None)    
+    else:
+        model = model_class(config)
+
+    model=Model(model,config,tokenizer,args)
+    if args.local_rank == 0:
+        torch.distributed.barrier()  # End of barrier to make sure only the first process in distributed training download model & vocab
+
+    logger.info("Training/evaluation parameters %s", args)
+
+    # Training
+    if args.do_train:
+        if args.local_rank not in [-1, 0]:
+            torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training process the dataset, and the others will use the cache
+
+        train_dataset = TextDataset(tokenizer, args,args.train_data_file)
+        if args.local_rank == 0:
+            torch.distributed.barrier()
+
+        train(args, train_dataset, model, tokenizer)
+
+
+
+    # Evaluation
+    results = {}
+    if args.do_eval and args.local_rank in [-1, 0]:
+        checkpoint_prefix = 'epoch_1/subject_model.pth' #'checkpoint-best-map/model.bin'
+        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))  
+        model.load_state_dict(torch.load(output_dir),strict=False)      
+        model.to(args.device)
+        result=evaluate(args, model, tokenizer)
+        logger.info("***** Eval results *****")
+        for key in sorted(result.keys()):
+            logger.info("  %s = %s", key, str(round(result[key],4)))
+            
+    if args.do_test and args.local_rank in [-1, 0]:
+        checkpoint_prefix = 'epoch_1/subject_model.pth' #'checkpoint-best-map/model.bin'
+        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))  
+        model.load_state_dict(torch.load(output_dir),strict=False)                  
+        model.to(args.device)
+        test(args, model, tokenizer)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()
+
+
+

Code-Code/Clone-detection-POJ-104/code/test.sh

@@ -0,0 +1,17 @@
+CUDA_VISIBLE_DEVICES=0,1  python run.py \
+    --output_dir=../model \
+    --model_type=roberta \
+    --config_name=microsoft/codebert-base \
+    --model_name_or_path=microsoft/codebert-base \
+    --tokenizer_name=roberta-base \
+    --do_test \
+    --train_data_file=../dataset/train.jsonl \
+    --test_data_file=../dataset/valid.jsonl \
+    --epoch 2 \
+    --block_size 400 \
+    --train_batch_size 8 \
+    --eval_batch_size 16 \
+    --learning_rate 2e-5 \
+    --max_grad_norm 1.0 \
+    --evaluate_during_training \
+    --seed 123456

Code-Code/Clone-detection-POJ-104/code/train.sh

@@ -0,0 +1,18 @@
+CUDA_VISIBLE_DEVICES=0,1  python run.py \
+    --output_dir=../model \
+    --model_type=roberta \
+    --config_name=microsoft/codebert-base \
+    --model_name_or_path=microsoft/codebert-base \
+    --tokenizer_name=roberta-base \
+    --do_train \
+    --train_data_file=../dataset/train.jsonl \
+    --eval_data_file=../dataset/valid.jsonl \
+    --test_data_file=../dataset/test.jsonl \
+    --epoch 2 \
+    --block_size 400 \
+    --train_batch_size 8 \
+    --eval_batch_size 16 \
+    --learning_rate 2e-5 \
+    --max_grad_norm 1.0 \
+    --evaluate_during_training \
+    --seed 123456

Code-Code/Clone-detection-POJ-104/dataset.zip

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

Code-Code/Clone-detection-POJ-104/model/epoch_0/subject_model.pth

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

Code-Code/Clone-detection-POJ-104/model/epoch_1/subject_model.pth

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

Code-Code/CodeCompletion-token/code/beam.py

@@ -0,0 +1,118 @@
+import torch
+import torch.nn as nn
+import torch
+from torch.autograd import Variable
+import copy
+
+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][:] = 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] in 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] in 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] in 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] not in 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:
+                tokens.append(tok)
+                if tok in self._eos:
+                    break
+            sentence.append(tokens)
+        return sentence

Code-Code/CodeCompletion-token/code/dataset.py

@@ -0,0 +1,261 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import absolute_import, division, print_function
+
+import argparse
+import glob
+import logging
+import os
+import pickle
+import random
+import re
+import gc
+import shutil
+import json
+
+import numpy as np
+import torch
+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,
+                          BertConfig, BertForMaskedLM, BertTokenizer,
+                          GPT2Config, GPT2LMHeadModel, GPT2Tokenizer,
+                          OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer,
+                          RobertaConfig, RobertaForMaskedLM, RobertaTokenizer,
+                          DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer)
+
+class TextDataset(Dataset):
+    def __init__(self, tokenizer, args, logger, file_type='train', block_size=1024):
+        if args.local_rank==-1:
+            local_rank=0
+            world_size=1
+        else:
+            local_rank=args.local_rank
+            world_size=torch.distributed.get_world_size()
+
+        if not os.path.exists(args.output_dir):
+            os.makedirs(args.output_dir)
+        cached_file = os.path.join(args.output_dir, file_type+"_langs_%s"%(args.langs)+"_blocksize_%d"%(block_size)+"_wordsize_%d"%(world_size)+"_rank_%d"%(local_rank))
+        if os.path.exists(cached_file) and not args.overwrite_cache:
+            if file_type == 'train':
+                logger.warning("Loading features from cached file %s", cached_file)
+            with open(cached_file, 'rb') as handle:
+                self.inputs = pickle.load(handle)
+
+        else:
+            self.inputs = []
+            if args.langs == 'all':
+                langs = os.listdir(args.data_dir)
+            else:
+                langs = [args.langs]
+
+            data=[]
+            for lang in langs:
+                datafile = os.path.join(args.data_dir, lang, file_type+'.pkl')
+                if file_type == 'train':
+                    logger.warning("Creating features from dataset file at %s", datafile)
+                # with open(datafile) as f:
+                #     data.extend([json.loads(x)['code'] for idx,x in enumerate(f.readlines()) if idx%world_size==local_rank])
+                dataset = pickle.load(open(datafile, 'rb'))
+                data.extend(['<s> '+' '.join(x['function'].split())+' </s>' for idx,x in enumerate(dataset) if idx%world_size==local_rank])
+
+            # random.shuffle(data)
+            data = data
+            length = len(data)
+            logger.warning("Data size: %d"%(length))
+            input_ids = []
+            for idx,x in enumerate(data):
+                try:
+                    input_ids.extend(tokenizer.encode(x))
+                except Exception:
+                    pass
+                if idx % (length//10) == 0:
+                    percent = idx / (length//10) * 10
+                    logger.warning("Rank %d, load %d"%(local_rank, percent))
+            del data
+            gc.collect()
+
+            length = len(input_ids)
+            for i in range(0, length-block_size, block_size):
+                self.inputs.append(input_ids[i : i + block_size])            
+            del input_ids
+            gc.collect()
+
+            if file_type == 'train':
+                logger.warning("Rank %d Training %d token, %d samples"%(local_rank, length, len(self.inputs)))
+                logger.warning("Saving features into cached file %s", cached_file)
+            with open(cached_file, 'wb') as handle:
+                pickle.dump(self.inputs, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+    def __len__(self):
+        return len(self.inputs)
+
+    def __getitem__(self, item):
+        return torch.tensor(self.inputs[item])
+
+class finetuneDataset(Dataset):
+    def __init__(self, tokenizer, args, logger, file_type='train', block_size=1024):
+        if args.local_rank==-1:
+            local_rank=0
+            world_size=1
+        else:
+            local_rank=args.local_rank
+            world_size=torch.distributed.get_world_size()
+
+        if not os.path.exists(args.output_dir):
+            os.makedirs(args.output_dir)
+        cached_file = os.path.join(args.output_dir, file_type+"_blocksize_%d"%(block_size)+"_wordsize_%d"%(world_size)+"_rank_%d"%(local_rank))
+        if os.path.exists(cached_file) and not args.overwrite_cache:
+            if file_type == 'train':
+                logger.warning("Loading features from cached file %s", cached_file)
+            with open(cached_file, 'rb') as handle:
+                self.inputs = pickle.load(handle)
+
+        else:
+            self.inputs = []
+
+            datafile = os.path.join(args.data_dir, f"{file_type}.txt")
+            if file_type == 'train':
+                logger.warning("Creating features from dataset file at %s", datafile)
+            with open(datafile) as f:
+                data = f.readlines()
+
+            length = len(data)
+            logger.info("Data size: %d"%(length))
+            input_ids = []
+            for idx,x in enumerate(data):
+                x = x.strip()
+                if x.startswith("<s>") and x.endswith("</s>"):
+                    pass
+                else:
+                    x = "<s> " + x + " </s>"
+                try:
+                    input_ids.extend(tokenizer.encode(x))
+                except Exception:
+                    pass
+                if idx % (length//10) == 0:
+                    percent = idx / (length//10) * 10
+                    logger.warning("Rank %d, load %d"%(local_rank, percent))
+            del data
+            gc.collect()
+
+            length = len(input_ids) // world_size
+            logger.info(f"tokens: {length*world_size}")
+            input_ids = input_ids[local_rank*length: (local_rank+1)*length]
+
+            for i in range(0, length-block_size, block_size):
+                self.inputs.append(input_ids[i : i + block_size])            
+            del input_ids
+            gc.collect()
+
+            if file_type == 'train':
+                logger.warning("Rank %d Training %d token, %d samples"%(local_rank, length, len(self.inputs)))
+                logger.warning("Saving features into cached file %s", cached_file)
+            with open(cached_file, 'wb') as handle:
+                pickle.dump(self.inputs, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+    def __len__(self):
+        return len(self.inputs)
+
+    def __getitem__(self, item):
+        return torch.tensor(self.inputs[item])
+
+class EvalDataset(Dataset):
+    def __init__(self, tokenizer, args, logger, file_type='train', block_size=1024):
+        if not os.path.exists(args.output_dir):
+            os.makedirs(args.output_dir)
+        cached_file = os.path.join(args.output_dir, file_type+"_blocksize_%d"%(block_size))
+        if os.path.exists(cached_file) and not args.overwrite_cache:
+            with open(cached_file, 'rb') as handle:
+                self.inputs = pickle.load(handle)
+
+        else:
+            self.inputs = []
+
+            datafile = os.path.join(args.data_dir, f"{file_type}.txt")
+            with open(datafile) as f:
+                data = f.readlines()
+
+            length = len(data)
+            logger.info("Data size: %d"%(length))
+            input_ids = []
+            for idx,x in enumerate(data):
+                x = x.strip()
+                if x.startswith("<s>") and x.endswith("</s>"):
+                    pass
+                else:
+                    x = "<s> " + x + " </s>"
+                try:
+                    input_ids.extend(tokenizer.encode(x))
+                except Exception:
+                    pass
+                if idx % (length//10) == 0:
+                    percent = idx / (length//10) * 10
+                    logger.warning("load %d"%(percent))
+            del data
+            gc.collect()
+
+            logger.info(f"tokens: {len(input_ids)}")
+            self.split(input_ids, tokenizer, logger, block_size=block_size)
+            del input_ids
+            gc.collect()
+
+            with open(cached_file, 'wb') as handle:
+                pickle.dump(self.inputs, handle, protocol=pickle.HIGHEST_PROTOCOL)
+    
+    def split(self, input_ids, tokenizer, logger, block_size=1024):
+        sample = []
+        i = 0
+        while i < len(input_ids):
+            sample = input_ids[i: i+block_size]
+            if len(sample) == block_size:
+                for j in range(block_size):
+                    if tokenizer.convert_ids_to_tokens(sample[block_size-1-j])[0] == '\u0120' or tokenizer.convert_ids_to_tokens(sample[block_size-1-j]).startswith("<NUM_LIT"):
+                        break
+                    if sample[block_size-1-j] in [tokenizer.bos_token_id, tokenizer.eos_token_id, tokenizer.sep_token_id]:
+                        if sample[block_size-1-j] != tokenizer.bos_token_id:
+                            j -= 1
+                        break
+                if j == block_size-1:
+                    print(tokenizer.decode(sample))
+                    exit()
+                sample = sample[: block_size-1-j]
+            # print(len(sample))
+            i += len(sample)
+            pad_len = block_size-len(sample)
+            sample += [tokenizer.pad_token_id]*pad_len
+            self.inputs.append(sample)
+
+            if len(self.inputs) % 10000 == 0:
+                logger.info(f"{len(self.inputs)} samples")
+
+
+    def __len__(self):
+        return len(self.inputs)
+
+    def __getitem__(self, item):
+        return torch.tensor(self.inputs[item])
+        
+
+
+class lineDataset(Dataset):
+    def __init__(self, tokenizer, args, logger, file_type='test', block_size=924):
+        datafile = os.path.join(args.data_dir, f"{file_type}.json")
+        with open(datafile) as f:
+            datas = f.readlines()
+
+        length = len(datas)
+        logger.info("Data size: %d"%(length))
+        self.inputs = []
+        self.gts = []
+        for data in datas:
+            data = json.loads(data.strip())
+            self.inputs.append(tokenizer.encode(data["input"])[-block_size:])
+            self.gts.append(data["gt"])
+
+    def __len__(self):
+        return len(self.inputs)
+
+    def __getitem__(self, item):
+        return torch.tensor(self.inputs[item]), self.gts[item]

Code-Code/CodeCompletion-token/code/eval.sh

@@ -0,0 +1,20 @@
+LANG=java                       # set python for py150
+DATADIR=../dataset/javaCorpus/token_completion
+LITFILE=../dataset/javaCorpus/literals.json
+OUTPUTDIR=../model/javaCorpus
+PRETRAINDIR=microsoft/CodeGPT-small-java        # microsoft/CodeGPT-small-py for py150
+LOGFILE=eval_javaCorpus.log
+
+CUDA_VISIBLE_DEVICES=0 python run_lm.py \
+        --data_dir=$DATADIR \
+        --lit_file=$LITFILE \
+        --langs=$LANG \
+        --output_dir=$OUTPUTDIR \
+        --pretrain_dir=$OUTPUTDIR \
+        --log_file=$LOGFILE \
+        --model_type=gpt2 \
+        --block_size=512 \
+        --do_eval \
+        --per_gpu_eval_batch_size=16 \
+        --logging_steps=100 \
+        --seed=42 

Code-Code/CodeCompletion-token/code/evaluate.sh

@@ -0,0 +1,3 @@
+python evaluator.py \
+    -a=../dataset/javaCorpus/token_completion/test.txt \
+    -p=../model/javaCorpus/predictions.txt

Code-Code/CodeCompletion-token/code/evaluator.py

@@ -0,0 +1,36 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+import os
+import logging
+import argparse
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+def main():
+    parser = argparse.ArgumentParser(description='Evaluate leaderboard predictions for code completion (token level).')
+    parser.add_argument('--answers', '-a', required=True, help="filename of the labels, in txt format.")
+    parser.add_argument('--predictions', '-p', required=True, help="filename of the leaderboard predictions, in txt format.")
+    args = parser.parse_args()
+
+    preds = open(args.predictions, "r").readlines()
+    gts = open(args.answers, "r").readlines()
+
+    assert len(preds) == len(gts), f"Samples of predictions and answers are not equal, {len(preds)}: {len(gts)}"
+
+    total = 0
+    correct = 0.0
+    for pred, gt in zip(preds, gts):
+        pred = pred.split()
+        gt = gt.split()
+        assert len(pred) == len(gt), f"Sequence length of prediction and answer are not equal, {len(pred)}: {len(gt)}"
+        for x, y in zip(pred, gt):
+            if y not in ["<s>", "</s>", "<EOL>", "<pad>"]:
+                total += 1
+                if x == y:
+                    correct += 1
+    
+    logger.info(f"Total {total} tokens, accuracy: {round(correct/total*100, 2)}")
+
+if __name__ == "__main__":
+    main()

Code-Code/CodeCompletion-token/code/model.py

@@ -0,0 +1,68 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class RNNModel(nn.Module):
+    """Container module with an encoder, a recurrent module, and a decoder."""
+
+    def __init__(self, ntoken, ninp, nhid, nlayers, dropout=0.5, tie_weights=False):
+        super(RNNModel, self).__init__()
+        self.ntoken = ntoken
+        self.drop = nn.Dropout(dropout)
+        self.encoder = nn.Embedding(ntoken, ninp)
+        self.rnn = nn.LSTM(ninp, nhid, nlayers, dropout=dropout, batch_first=True)
+        self.decoder = nn.Linear(nhid, ntoken)
+        self.criterion = nn.CrossEntropyLoss()
+
+        # Optionally tie weights as in:
+        # "Using the Output Embedding to Improve Language Models" (Press & Wolf 2016)
+        # https://arxiv.org/abs/1608.05859
+        # and
+        # "Tying Word Vectors and Word Classifiers: A Loss Framework for Language Modeling" (Inan et al. 2016)
+        # https://arxiv.org/abs/1611.01462
+        if tie_weights:
+            if nhid != ninp:
+                raise ValueError('When using the tied flag, nhid must be equal to emsize')
+            self.decoder.weight = self.encoder.weight
+
+        self.init_weights()
+
+        self.nhid = nhid
+        self.nlayers = nlayers
+
+    def init_weights(self):
+        initrange = 0.1
+        nn.init.uniform_(self.encoder.weight, -initrange, initrange)
+        nn.init.zeros_(self.decoder.weight)
+        nn.init.uniform_(self.decoder.weight, -initrange, initrange)
+
+    def forward(self, input, hidden=None, labels=None):
+        emb = self.encoder(input)
+        if hidden is not None:
+            output, hidden = self.rnn(emb, hidden)
+        else:
+            output, hidden = self.rnn(emb)
+        output = self.drop(output)
+        output = self.decoder(output)
+        # decoded = decoded.view(-1, self.ntoken)
+        # output = F.log_softmax(decoded, dim=1)
+        if labels is not None:
+            shift_logits = output[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss = self.criterion(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
+            return loss, output, hidden
+        else:
+            return output, hidden
+
+    def init_hidden(self, bsz):
+        weight = next(self.parameters())
+        if self.rnn_type == 'LSTM':
+            return (weight.new_zeros(self.nlayers, bsz, self.nhid),
+                    weight.new_zeros(self.nlayers, bsz, self.nhid))
+        else:
+            return weight.new_zeros(self.nlayers, bsz, self.nhid)
+
+    

Code-Code/CodeCompletion-token/code/run_lm.py

@@ -0,0 +1,728 @@
+# 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.
+"""
+Code completion (both token level and line level) pipeline in CodeXGLUE
+"""
+
+from __future__ import absolute_import, division, print_function
+
+import argparse
+import glob
+import logging
+import os
+import pickle
+import random
+import re
+import shutil
+import json
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Dataset, SequentialSampler, RandomSampler,TensorDataset
+from torch.utils.data.distributed import DistributedSampler
+from dataset import TextDataset, finetuneDataset, EvalDataset, lineDataset
+from beam import Beam
+
+from transformers import (WEIGHTS_NAME, AdamW, get_linear_schedule_with_warmup,
+                          BertConfig, BertForMaskedLM, BertTokenizer,
+                          GPT2Config, GPT2LMHeadModel, GPT2Tokenizer,
+                          OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer,
+                          RobertaConfig, RobertaForMaskedLM, RobertaTokenizer,
+                          DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer)
+from model import RNNModel
+
+# 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__)
+
+MODEL_CLASSES = {
+    'gpt2': (GPT2Config, GPT2LMHeadModel, GPT2Tokenizer),
+    'rnn': (GPT2Config, RNNModel, GPT2Tokenizer),
+    'openai-gpt': (OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
+    'bert': (BertConfig, BertForMaskedLM, BertTokenizer),
+    'roberta': (RobertaConfig, RobertaForMaskedLM, RobertaTokenizer),
+    'distilbert': (DistilBertConfig, DistilBertForMaskedLM, DistilBertTokenizer)
+}
+
+
+
+def load_and_cache_examples(args, tokenizer, evaluate=False):
+    if args.not_pretrain:
+        dataset = finetuneDataset(tokenizer, args, logger, file_type='dev' if evaluate else 'train', 
+                                block_size=args.block_size)
+    else:
+        dataset = TextDataset(tokenizer, args, logger, file_type='dev' if evaluate else 'train',
+                                block_size=args.block_size)
+    return dataset         
+
+def set_seed(args):
+    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 update_config(args, config):
+    # config.n_positions = config.n_ctx = args.block_size
+    config.vocab_size = args.vocab_size
+
+def get_special_tokens(path):
+    lits = json.load(open(path))
+    tokens = ["<STR_LIT>", "<NUM_LIT>", "<CHAR_LIT>"]
+    for lit in lits["str"]:
+        tokens.append(f"<STR_LIT:{lit}>")
+    for lit in lits["num"]:
+        tokens.append(f"<NUM_LIT:{lit}>")
+    for lit in lits["char"]:
+        tokens.append(f"<CHAR_LIT:{lit}>")
+    return tokens
+
+
+
+def train(args, train_dataset, model, tokenizer, fh, pool):
+    """ Train the model """
+    if args.local_rank in [-1, 0]:
+        args.tensorboard_dir = os.path.join(args.output_dir, 'tensorboard')
+        if not os.path.exists(args.tensorboard_dir):
+            os.makedirs(args.tensorboard_dir)
+    
+    args.batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
+    train_sampler = RandomSampler(train_dataset)
+    
+    train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.batch_size, drop_last=True)
+    total_examples = len(train_dataset) * (
+                    torch.distributed.get_world_size() if args.local_rank != -1 else 1)
+    batch_size = args.batch_size * args.gradient_accumulation_steps * (
+                    torch.distributed.get_world_size() if args.local_rank != -1 else 1)
+    # if args.max_steps > 0:
+    #     t_total = args.max_steps
+    #     args.num_train_epochs = args.max_steps // (len(train_dataloader) // args.gradient_accumulation_steps) + 1
+    if args.num_train_epochs > 0:
+        t_total = total_examples // batch_size * args.num_train_epochs
+    args.max_steps = t_total
+    model.to(args.device)
+    if args.local_rank not in [-1, 0]:
+        torch.distributed.barrier()  
+    # 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=t_total)
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    # scheduler_last = os.path.join(checkpoint_last, 'scheduler.pt')
+    optimizer_last = os.path.join(checkpoint_last, 'optimizer.pt')
+    # if os.path.exists(scheduler_last):
+    #     scheduler.load_state_dict(torch.load(scheduler_last, map_location="cpu"))
+    if os.path.exists(optimizer_last):
+        logger.warning(f"Loading optimizer from {optimizer_last}")
+        optimizer.load_state_dict(torch.load(optimizer_last, map_location="cpu"))   
+    if args.local_rank == 0:
+        torch.distributed.barrier()   
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+
+    # multi-gpu training (should be after apex fp16 initialization)
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Distributed training (should be after apex fp16 initialization)
+    if args.local_rank != -1:
+        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank%args.gpu_per_node],
+                                                          output_device=args.local_rank%args.gpu_per_node)
+
+    # Train!
+    logger.info("***** Running training *****")
+    logger.info("  Num examples = %d", total_examples )
+    logger.info("  Num epoch = %d", t_total*batch_size//total_examples)
+    logger.info("  Instantaneous batch size per GPU = %d", args.per_gpu_train_batch_size)
+    logger.info("  Total train batch size (w. parallel, distributed & accumulation) = %d", batch_size)
+    logger.info("  Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
+    logger.info("  Total optimization steps = %d", t_total)
+    
+    global_step = args.start_step
+    tr_loss, logging_loss,avg_loss,tr_nb = 0.0, 0.0, 0.0, global_step
+    # model.resize_token_embeddings(len(tokenizer))
+    model.zero_grad()
+    set_seed(args)  # Added here for reproducibility (even between python 2 and 3)
+ 
+    for idx in range(args.start_epoch, int(args.num_train_epochs)): 
+        for step, batch in enumerate(train_dataloader):
+            inputs, labels = (batch, batch)
+            inputs = inputs.to(args.device)
+            labels = labels.to(args.device)
+            model.train()
+            outputs = model(inputs, labels=labels)
+            loss = outputs[0]
+
+            if args.n_gpu > 1:
+                loss = loss.mean()  # mean() to average on multi-gpu parallel training
+            if args.gradient_accumulation_steps > 1:
+                loss = loss / args.gradient_accumulation_steps
+
+            if args.fp16:
+                with amp.scale_loss(loss, optimizer) as scaled_loss:
+                    scaled_loss.backward()
+                torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
+            else:
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+
+            tr_loss += loss.item()
+                
+            if (step + 1) % args.gradient_accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+                scheduler.step()  
+                global_step += 1
+                output_flag=True
+                avg_loss=round(np.exp((tr_loss - logging_loss) /(global_step- tr_nb)),4)
+                if global_step % args.logging_steps == 0:
+                    logger.info("  steps: %s  ppl: %s  lr: %s", global_step, round(avg_loss,5), scheduler.get_last_lr()[0])
+                if args.local_rank in [-1, 0] and args.logging_steps > 0 and global_step % args.logging_steps == 0:
+                    # Log metrics
+                    logging_loss = tr_loss
+                    tr_nb=global_step
+
+                if args.local_rank in [-1, 0] and args.save_steps > 0 and global_step % args.save_steps == 0:
+                    checkpoint_prefix = "checkpoint"
+                    # Save model checkpoint
+                    if args.evaluate_during_training:  # Only evaluate when single GPU otherwise metrics may not average well
+                        results = evaluate(args, model, tokenizer, eval_when_training=True)
+                        for key, value in results.items():
+                            logger.info("  %s = %s", key, round(value,4))                    
+                        output_dir = os.path.join(args.output_dir, '{}-{}-{}'.format(checkpoint_prefix, global_step, round(results['perplexity'],4)))
+                    else:
+                        output_dir = os.path.join(args.output_dir, "{}-{}".format(checkpoint_prefix, global_step))
+                    if not os.path.exists(output_dir):
+                        os.makedirs(output_dir)
+                    model_to_save = (
+                        model.module if hasattr(model, "module") else model
+                    )  # Take care of distributed/parallel training
+                    if args.model_type == "rnn":
+                        torch.save(model_to_save.state_dict(), os.path.join(output_dir, "model.pt"))
+                    else:
+                        model_to_save.save_pretrained(output_dir)
+                    tokenizer.save_pretrained(output_dir)
+
+                    torch.save(args, os.path.join(output_dir, "training_args.bin"))
+                    logger.info("Saving model checkpoint to %s", output_dir)
+
+                    # _rotate_checkpoints(args, checkpoint_prefix)
+                    last_output_dir = os.path.join(args.output_dir, 'checkpoint-last')
+                    if not os.path.exists(last_output_dir):
+                        os.makedirs(last_output_dir)
+                    if args.model_type == "rnn":
+                        torch.save(model_to_save.state_dict(), os.path.join(last_output_dir, "model.pt"))
+                    else:
+                        model_to_save.save_pretrained(last_output_dir)
+                    tokenizer.save_pretrained(last_output_dir)
+                    idx_file = os.path.join(last_output_dir, 'idx_file.txt')
+                    with open(idx_file, 'w', encoding='utf-8') as idxf:
+                        idxf.write(str(0) + '\n')
+
+                    torch.save(optimizer.state_dict(), os.path.join(last_output_dir, "optimizer.pt"))
+                    # torch.save(scheduler.state_dict(), os.path.join(last_output_dir, "scheduler.pt"))
+                    logger.info("Saving optimizer and scheduler states to %s", last_output_dir)
+
+                    step_file = os.path.join(last_output_dir, 'step_file.txt')
+                    with open(step_file, 'w', encoding='utf-8') as stepf:
+                        stepf.write(str(global_step) + '\n')
+                    
+
+            if args.max_steps > 0 and global_step > args.max_steps:
+                break
+
+        # 每一轮记录checkpoint
+        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)
+
+        if args.max_steps > 0 and global_step > args.max_steps:
+            break
+
+    return global_step, tr_loss / global_step
+
+
+def evaluate(args, model, tokenizer, prefix="", eval_when_training=False):
+    # Loop to handle MNLI double evaluation (matched, mis-matched)
+    eval_output_dir = args.output_dir
+
+    eval_dataset = load_and_cache_examples(args, tokenizer, evaluate=True)
+
+    if not os.path.exists(eval_output_dir) and args.local_rank in [-1, 0]:
+        os.makedirs(eval_output_dir)
+
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    # Note that DistributedSampler samples randomly
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size, drop_last=True)
+
+    # multi-gpu evaluate
+    if args.n_gpu > 1 and eval_when_training is False:
+        model = torch.nn.DataParallel(model)
+
+    # Eval!
+    #logger.info("***** Running evaluation {} *****".format(prefix))
+    #logger.info("  Num examples = %d", len(eval_dataset))
+    #logger.info("  Batch size = %d", args.eval_batch_size)
+    eval_loss = 0.0
+    nb_eval_steps = 0
+    model.eval()
+       
+    for batch in eval_dataloader:
+        inputs, labels = (batch, batch)
+        inputs = inputs.to(args.device)
+        labels = labels.to(args.device)
+
+        with torch.no_grad():
+            outputs = model(inputs, labels=labels)
+            lm_loss = outputs[0]
+            eval_loss += lm_loss.mean().item()
+        nb_eval_steps += 1
+
+    eval_loss = eval_loss / nb_eval_steps
+    perplexity = torch.exp(torch.tensor(eval_loss))
+
+    result = {
+        "perplexity": float(perplexity)
+    }
+
+    output_eval_file = os.path.join(eval_output_dir, prefix, "eval_results.txt")
+    with open(output_eval_file, "w") as writer:
+        #logger.info("***** Eval results {} *****".format(prefix))
+        for key in sorted(result.keys()):
+            #logger.info("  %s = %s", key, str(result[key]))
+            writer.write("%s = %s\n" % (key, str(result[key])))
+
+    return result
+
+def eval_acc(args, model, tokenizer, file_type='test'):
+    """
+    Evaluate token level code completion on accuracy.
+
+    This function can only used to evaluate accuracy, but not inference, because the inputs are previous sub-tokens but not tokens.
+    But it can be guaranteed that the accuracy in this function is the same as the real token level completion.
+    The reason is:
+    Assuming the inputs are "context_len = 100 <EOL> masks = np . zeros (", and the ground truth is "context_len".
+    Due to our bpe encoding, the model have to outputs "context", "_" and "len" in 3 time step, i.e. gt0="context", gt1="_", gt2="len".
+    In a real inference scenario:
+    time step 0, inputs "context_len = 100 <EOL> masks = np . zeros ( ", model outputs: out0;
+    time step 1, inputs: in1=out0, outputs: out1
+    ... until the model outputs a complete token
+    But in this function, no matter out0 is, in1=gt0="context".
+    That is to say, in this function, we feed ground truth but not output sub-token when we predict the next token which is split by bpe.
+    So obviouly we would get different predictions from the real token completion scenario.
+    However, if we calculate token leval accuracy, 
+    if and only if the model predicts every sub-token correctly, the complete token can be seen correct.
+    In this situation, out0==gt0, out1==gt1, so it doesn't matter we feed gt or output to model.
+    In summary, this function can make models oupout the same complete token if this token equals to ground truth, 
+    if not, the model might predict a different token from the real completion scenario, but all wrong.
+    So it would not affect the token level accuracy.
+
+    I use this trick to speed up evaluation due to the large test set.
+    """
+    eval_dataset = EvalDataset(tokenizer, args, logger, file_type=file_type, block_size=args.block_size)
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size)
+    model.to(args.device)
+    # multi-gpu training (should be after apex fp16 initialization)
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Distributed training (should be after apex fp16 initialization)
+    if args.local_rank != -1:
+        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank%args.gpu_per_node],
+                                                          output_device=args.local_rank%args.gpu_per_node)
+
+    def DecodeIds(idxs):
+        codes = ""
+        for idx in idxs:
+            to_add = tokenizer.convert_ids_to_tokens(idx)
+            if tokenizer.convert_ids_to_tokens(idx)[0] == '\u0120':
+                if not codes.endswith(" "):
+                    codes += " " + to_add[1:]
+                else:
+                    codes += to_add[1:]
+            elif (
+                idx in [tokenizer.bos_token_id, tokenizer.eos_token_id, tokenizer.sep_token_id, tokenizer.pad_token_id] or
+                tokenizer.convert_ids_to_tokens(idx).startswith("<NUM_LIT")
+            ):
+                codes += " " + to_add + " "
+            else:
+                codes += to_add
+        return codes.strip(" ")
+    
+    model.eval()
+
+    correct = 0.0
+    total = 0
+
+    total_pred = []
+    total_gt = []
+
+    for step, batch in enumerate(eval_dataloader):
+        inputs = batch.to(args.device)
+
+        with torch.no_grad():
+            outputs = model(inputs)
+            pred_scores = outputs[0]
+            pred_ids = pred_scores.argmax(-1)
+
+        all_pred = []
+        all_gt = []
+        prev_pred = None
+        for pred, gt in zip(pred_ids, inputs):
+            pred = pred.cpu().tolist()
+            gt = gt.cpu().tolist()
+
+            for i, y in enumerate(gt):
+                if i == 0:
+                    if y in [tokenizer.bos_token_id, tokenizer.eos_token_id, tokenizer.sep_token_id, tokenizer.pad_token_id]:
+                        now_gt = [y]
+                        now_pred = [0] if prev_pred is None else [prev_pred]
+                        all_pred.append(DecodeIds(now_pred).strip().split()[0])
+                        all_gt.append(DecodeIds(now_gt).strip())
+                        now_gt = []
+                        now_pred = []
+                    else:
+                        now_gt = [y]
+                        now_pred = [0] if prev_pred is None else [prev_pred]
+                else:
+                    if tokenizer.convert_ids_to_tokens(y)[0] == '\u0120':
+                        if len(now_gt) > 0:
+                            try:
+                                all_pred.append(DecodeIds(now_pred).strip().split()[0])
+                            except IndexError:
+                                all_pred.append("<SPACE>")
+                            all_gt.append(DecodeIds(now_gt).strip())
+                            now_gt = []
+                            now_pred = []
+                    if y in [tokenizer.bos_token_id, tokenizer.eos_token_id, tokenizer.sep_token_id, tokenizer.pad_token_id] or tokenizer.convert_ids_to_tokens(y).startswith("<NUM_LIT"):
+                        if len(now_gt) > 0:
+                            try:
+                                all_pred.append(DecodeIds(now_pred).strip().split()[0])
+                            except IndexError:
+                                all_pred.append("<SPACE>")
+                            all_gt.append(DecodeIds(now_gt).strip())
+                        now_gt = [y]
+                        now_pred = [pred[i-1]]
+                        try:
+                            all_pred.append(DecodeIds(now_pred).strip().split()[0])
+                        except IndexError:
+                            all_pred.append("<SPACE>")
+                        all_gt.append(DecodeIds(now_gt).strip())
+                        now_gt = []
+                        now_pred = []
+                        continue
+                    now_gt.append(y)
+                    now_pred.append(pred[i-1])
+        assert len(all_pred) == len(all_gt)
+
+        total_pred.extend(all_pred)
+        total_gt.extend(all_gt)
+
+
+        for x, y in zip(all_pred, all_gt):
+            if y not in ["<s>", "</s>", "<EOL>", "<pad>"]:
+                total += 1
+                if x == y:
+                    correct += 1
+        
+        if step % args.logging_steps == 0:
+            logger.info(f"{step} are done!")
+            logger.info(f"{total}, {correct/total}")
+
+    # pickle.dump(total_pred, open(os.path.join(args.output_dir, "preds.pkl"), "wb"))
+    # pickle.dump(total_gt, open(os.path.join(args.output_dir, "gts.pkl"), "wb"))
+
+    saved_file = os.path.join(args.output_dir, "predictions.txt")
+    total_samples = post_process(args, total_pred, total_gt, open(os.path.join(args.data_dir, f"{file_type}.txt")).readlines(), saved_file)
+    logger.info(f"Eval on {total_samples}, saved at {saved_file}")
+    
+    return total, correct
+
+def post_process(args, preds, gts, true_gts, saved_file):
+    wf = open(saved_file, "w")
+
+    cnt = 0
+    new_gt = []
+    new_pred = []
+    for i, (pred,gt) in enumerate(zip(preds,gts)):
+        if gt in ["", "<pad>"]:
+            continue
+        new_gt.append(gt)
+        new_pred.append(pred.replace(" ", ""))
+        if gt == "</s>":
+            gt_str = " ".join(new_gt)
+            pred_str = " ".join(new_pred)
+            assert gt_str == true_gts[cnt].strip(), f"{cnt} sample gt_str != true_gt"
+            wf.write(pred_str+"\n")
+            cnt += 1
+            new_gt = []
+            new_pred = []
+    
+    return cnt
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    ## Required parameters
+    parser.add_argument("--data_dir", default=None, type=str, required=True,
+                        help="The input data path.")
+    parser.add_argument("--langs", default=None, type=str, required=True,
+                        help="Languages to train, if all, train all languages in data_dir")
+    parser.add_argument("--output_dir", default=None, type=str, required=True,
+                        help="The output directory where the model predictions and checkpoints will be written.")
+
+    ## Other parameters
+    parser.add_argument("--model_type", default="gpt2", type=str,
+                        help="The model architecture to be fine-tuned.")
+    parser.add_argument("--pretrain_dir", default="", type=str,
+                        help="The output directory where the model predictions and checkpoints will be written.")
+    parser.add_argument("--config_dir", type=str,
+                        help="config name. Required when training from scratch")
+    parser.add_argument("--tokenizer_dir", type=str,
+                        help="Pre-trained tokenizer dir. Required when training from scratch")
+    parser.add_argument("--lit_file", type=str,
+                        help="literals json file")
+    parser.add_argument("--load_name", type=str, default="pretrained", 
+                        help="Load pretrained model name")
+
+    parser.add_argument("--mlm", action='store_true',
+                        help="Train with masked-language modeling loss instead of language modeling.")
+    parser.add_argument("--mlm_probability", type=float, default=0.15,
+                        help="Ratio of tokens to mask for masked language modeling loss")
+
+    parser.add_argument("--cache_dir", default="", type=str,
+                        help="Optional directory to store the pre-trained models downloaded from s3 (instread of the default one)")
+    parser.add_argument("--block_size", default=1024, type=int,
+                        help="Optional input sequence length after tokenization."
+                             "The training dataset will be truncated in block of this size for training."
+                             "Default to the model max input length for single sentence inputs (take into account special tokens).")
+    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("--evaluate_during_training", action='store_true',
+                        help="Run evaluation during training at each logging step.")
+    parser.add_argument("--do_lower_case", action='store_true',
+                        help="Set this flag if you are using an uncased model.")
+
+    parser.add_argument("--per_gpu_train_batch_size", default=4, type=int,
+                        help="Batch size per GPU/CPU for training.")
+    parser.add_argument("--per_gpu_eval_batch_size", default=12, 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("--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=1.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("--warmup_steps", default=0, type=int,
+                        help="Linear warmup over warmup_steps.")
+
+    parser.add_argument('--logging_steps', type=int, default=1000,
+                        help="Log every X updates steps.")
+    parser.add_argument('--save_steps', type=int, default=5000,
+                        help="Save checkpoint every X updates steps.")
+    parser.add_argument('--save_total_limit', type=int, default=None,
+                        help='Limit the total amount of checkpoints, delete the older checkpoints in the output_dir, does not delete by default')
+    parser.add_argument("--eval_all_checkpoints", action='store_true',
+                        help="Evaluate all checkpoints starting with the same prefix as model_name_or_path ending and ending with step number")
+    parser.add_argument("--no_cuda", action='store_true',
+                        help="Avoid using CUDA when available")
+    parser.add_argument('--overwrite_output_dir', action='store_true',
+                        help="Overwrite the content of the output directory")
+    parser.add_argument('--overwrite_cache', action='store_true',
+                        help="Overwrite the cached training and evaluation sets")
+    parser.add_argument('--seed', type=int, default=42,
+                        help="random seed for initialization")
+    parser.add_argument('--not_pretrain', action='store_true',
+                        help="use different dataset")
+
+    parser.add_argument('--fp16', action='store_true',
+                        help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit")
+    parser.add_argument('--fp16_opt_level', type=str, default='O1',
+                        help="For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
+                             "See details at https://nvidia.github.io/apex/amp.html")
+    parser.add_argument("--local_rank", type=int, default=-1,
+                        help="For distributed training: local_rank")
+    parser.add_argument("--node_index", type=int, default=-1,
+                        help="node index if multi-node running")    
+    parser.add_argument("--gpu_per_node", type=int, default=-1,
+                        help="num of gpus per node")  
+    parser.add_argument('--server_ip', type=str, default='', help="For distant debugging.")
+    parser.add_argument('--server_port', type=str, default='', help="For distant debugging.")
+
+    parser.add_argument('--log_file', type=str, default='')
+    parser.add_argument('--tensorboard_dir', type=str)  
+    
+    pool = None
+    args = parser.parse_args()
+
+    # args.output_dir = os.path.join(args.output_dir, args.dataset)
+
+    if args.model_type in ["bert", "roberta", "distilbert"] and not args.mlm:
+        raise ValueError("BERT and RoBERTa do not have LM heads but masked LM heads. They must be run using the --mlm "
+                         "flag (masked language modeling).")
+
+    if os.path.exists(args.output_dir) and os.listdir(
+            args.output_dir) and args.do_train and not args.overwrite_output_dir:
+        raise ValueError(
+            "Output directory ({}) already exists and is not empty. Use --overwrite_output_dir to overcome.".format(
+                args.output_dir))
+
+    # Setup distant debugging if needed
+    if args.server_ip and args.server_port:
+        # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
+        import ptvsd
+        print("Waiting for debugger attach")
+        ptvsd.enable_attach(address=(args.server_ip, args.server_port), redirect_output=True)
+        ptvsd.wait_for_attach()
+
+    logger.info("local_rank: %d, node_index: %d, gpu_per_node: %d"%(args.local_rank, args.node_index, args.gpu_per_node))
+    # 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.local_rank += args.node_index * args.gpu_per_node
+        args.n_gpu = 1
+    args.device = device
+    # args.batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
+
+    # Setup logging
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s -   %(message)s',
+                        datefmt='%m/%d/%Y %H:%M:%S',
+                        level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN)
+    logger.warning("Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s, world size: %s",
+                   args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.fp16,
+                   torch.distributed.get_world_size() if args.local_rank != -1 else 1)
+
+    # 使用FileHandler输出到文件
+    fh = logging.FileHandler(args.log_file)
+    logger.addHandler(fh)
+
+    # Set seed
+    set_seed(args)
+
+    # Load pretrained model and tokenizer
+    if args.local_rank not in [-1, 0]:
+        torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training download model & vocab
+
+    args.start_epoch = 0
+    args.start_step = 0
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    if args.do_train and os.path.exists(checkpoint_last) and os.listdir(checkpoint_last):
+        args.pretrain_dir = os.path.join(checkpoint_last)
+        args.config_name = os.path.join(checkpoint_last, 'config.json')
+        idx_file = os.path.join(checkpoint_last, 'idx_file.txt')
+        with open(idx_file, encoding='utf-8') as idxf:
+            args.start_epoch = int(idxf.readlines()[0].strip()) + 1
+
+        step_file = os.path.join(checkpoint_last, 'step_file.txt')
+        if os.path.exists(step_file):
+            with open(step_file, encoding='utf-8') as stepf:
+                args.start_step = int(stepf.readlines()[0].strip())
+
+        logger.info("reload model from {}, resume from {} steps".format(checkpoint_last, args.start_step))
+
+    # get special tokens
+    special_tokens = get_special_tokens(args.lit_file)
+
+    # Load pre-trained model
+    config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
+    pretrained = checkpoint_last #args.pretrain_dir
+    if pretrained:
+        tokenizer = tokenizer_class.from_pretrained(pretrained, do_lower_case=args.do_lower_case, sep_token='<EOL>', bos_token='<s>', eos_token='</s>', pad_token='<pad>', unk_token='<|UNKNOWN|>', additional_special_tokens=special_tokens)
+        if args.model_type == "rnn":
+            model = model_class(len(tokenizer), 768, 768, 1)
+            model_last = os.path.join(pretrained, 'model.pt')
+            if os.path.exists(model_last):
+                logger.warning(f"Loading model from {model_last}")
+                model.load_state_dict(torch.load(model_last, map_location="cpu")) 
+        else:
+            model = model_class.from_pretrained(pretrained)
+            model.resize_token_embeddings(len(tokenizer))
+    else:
+        tokenizer = tokenizer_class.from_pretrained(args.tokenizer_dir, sep_token='<EOL>', bos_token='<s>', eos_token='</s>', pad_token='<pad>', unk_token='<|UNKNOWN|>', additional_special_tokens=special_tokens)
+        args.vocab_size = len(tokenizer)
+        if args.model_type == "rnn":
+            model = model_class(len(tokenizer), 768, 768, 1)
+        else:
+            config = config_class.from_pretrained(args.config_dir)
+            model = model_class(config)
+            model.resize_token_embeddings(len(tokenizer))
+
+
+    model_parameters = model.parameters()
+    num_params = sum([np.prod(p.size()) for p in model_parameters])
+    logger.info(f"Model has a total of {num_params} trainable parameters")
+
+    if args.local_rank == 0:
+        torch.distributed.barrier()  # End of barrier to make sure only the first process in distributed training download model & vocab
+
+    logger.info("Training/evaluation parameters %s", args)
+
+    # Training
+    if args.do_train:
+        train_dataset = load_and_cache_examples(args, tokenizer, evaluate=False)
+
+        global_step, tr_loss = train(args, train_dataset, model, tokenizer, fh, pool)
+        logger.info(" global_step = %s, average loss = %s", global_step, tr_loss)
+
+    # Only works on single GPU
+    if args.do_eval:
+        checkpoint_prefix = 'epoch_5/subject_model.pth'
+        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))  
+        model.load_state_dict(torch.load(output_dir))                  
+        model.to(args.device)
+        # 不要用dev文件，否则会在EvalDataset的__init__中检测不通过，被exit
+        # dev_total, dev_cr = eval_acc(args, model, tokenizer, 'dev')
+        # logger.info(f"Dev total tokens: {dev_total}, accuracy: {dev_cr/dev_total}")
+        test_total, test_cr = eval_acc(args, model, tokenizer, 'test')
+        logger.info(f"Test total tokens: {test_total}, accuracy: {test_cr/test_total}")
+
+
+if __name__ == "__main__":
+    main()

Code-Code/CodeCompletion-token/code/train.sh

@@ -0,0 +1,31 @@
+LANG=java                       # set python for py150
+DATADIR=../dataset/javaCorpus/token_completion
+LITFILE=../dataset/javaCorpus/literals.json
+OUTPUTDIR=../model/javaCorpus
+PRETRAINDIR=microsoft/CodeGPT-small-java        # microsoft/CodeGPT-small-py for py150
+LOGFILE=train_javaCorpus.log
+PER_NODE_GPU=4       # modify YOUR_GPU_NUM
+
+CUDA_VISIBLE_DEVICES=0,1,2,3 python run_lm.py \
+        --data_dir=$DATADIR \
+        --lit_file=$LITFILE \
+        --langs=$LANG \
+        --output_dir=$OUTPUTDIR \
+        --pretrain_dir=$PRETRAINDIR \
+        --log_file=$LOGFILE \
+        --model_type=gpt2 \
+        --block_size=512 \
+        --do_train \
+        --gpu_per_node $PER_NODE_GPU \
+        --learning_rate=8e-5 \
+        --weight_decay=0.01 \
+        --evaluate_during_training \
+        --per_gpu_train_batch_size=1 \
+        --per_gpu_eval_batch_size=4 \
+        --gradient_accumulation_steps=4 \
+        --num_train_epochs=5 \
+        --logging_steps=100 \
+        --save_steps=1000 \
+        --seed=42 \
+        --overwrite_output_dir \
+        --not_pretrain

Code-Code/CodeCompletion-token/data.zip

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

Code-Code/CodeCompletion-token/model/javaCorpus/epoch_1/subject_model.pth

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

Code-Code/CodeCompletion-token/model/javaCorpus/epoch_2/subject_model.pth

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

Code-Code/CodeCompletion-token/model/javaCorpus/epoch_3/subject_model.pth

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

Code-Code/CodeCompletion-token/model/javaCorpus/epoch_4/subject_model.pth

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

Code-Code/CodeCompletion-token/model/javaCorpus/epoch_5/subject_model.pth

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

Code-Code/Defect-detection/code/eval.sh

@@ -0,0 +1,18 @@
+CUDA_VISIBLE_DEVICES=0,1  python run.py \
+    --output_dir=../model \
+    --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/valid.jsonl \
+    --epoch 5 \
+    --block_size 400 \
+    --train_batch_size 32 \
+    --eval_batch_size 64 \
+    --learning_rate 2e-5 \
+    --max_grad_norm 1.0 \
+    --evaluate_during_training \
+    --seed 123456

Code-Code/Defect-detection/code/evaluate.sh

@@ -0,0 +1 @@
+python evaluator.py -a ../dataset/valid.jsonl -p ../model/predictions.txt

Code-Code/Defect-detection/code/evaluator.py

@@ -0,0 +1,52 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+import logging
+import sys
+import json
+import numpy as np
+
+def read_answers(filename):
+    answers={}
+    with open(filename) as f:
+        for line in f:
+            line=line.strip()
+            js=json.loads(line)
+            answers[js['idx']]=js['target']
+    return answers
+
+def read_predictions(filename):
+    predictions={}
+    with open(filename) as f:
+        for line in f:
+            line=line.strip()
+            idx,label=line.split()
+            predictions[int(idx)]=int(label)
+    return predictions
+
+def calculate_scores(answers,predictions):
+    Acc=[]
+    for key in answers:
+        if key not in predictions:
+            logging.error("Missing prediction for index {}.".format(key))
+            sys.exit()
+        Acc.append(answers[key]==predictions[key])
+
+    scores={}
+    scores['Acc']=np.mean(Acc)
+    return scores
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='Evaluate leaderboard predictions for Defect Detection dataset.')
+    parser.add_argument('--answers', '-a',help="filename of the labels, in txt format.")
+    parser.add_argument('--predictions', '-p',help="filename of the leaderboard predictions, in txt format.")
+    
+
+    args = parser.parse_args()
+    answers=read_answers(args.answers)
+    predictions=read_predictions(args.predictions)
+    scores=calculate_scores(answers,predictions)
+    print(scores)
+
+if __name__ == '__main__':
+    main()

Code-Code/Defect-detection/code/model.py

@@ -0,0 +1,45 @@
+# 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
+from torch.nn import CrossEntropyLoss, MSELoss
+
+    
+    
+class Model(nn.Module):   
+    def __init__(self, encoder,config,tokenizer,args):
+        super(Model, self).__init__()
+        self.encoder = encoder
+        self.config=config
+        self.tokenizer=tokenizer
+        self.args=args
+    
+        # Define dropout layer, dropout_probability is taken from args.
+        self.dropout = nn.Dropout(args.dropout_probability)
+
+        
+    def forward(self, input_ids=None,labels=None, return_vec=None): 
+        outputs=self.encoder(input_ids,attention_mask=input_ids.ne(1))
+
+        if return_vec:
+            return outputs.pooler_output
+        outputs = outputs[0]
+        
+        # Apply dropout
+        outputs = self.dropout(outputs)
+
+        logits=outputs
+        prob=torch.sigmoid(logits)
+        if labels is not None:
+            labels=labels.float()
+            loss=torch.log(prob[:,0]+1e-10)*labels+torch.log((1-prob)[:,0]+1e-10)*(1-labels)
+            loss=-loss.mean()
+            return loss,prob
+        else:
+            return prob
+      
+        
+ 

Code-Code/Defect-detection/code/run.py

@@ -0,0 +1,598 @@
+# 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, division, print_function
+
+import argparse
+import glob
+import logging
+import os
+import pickle
+import random
+import re
+import shutil
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader, Dataset, SequentialSampler, RandomSampler,TensorDataset
+from torch.utils.data.distributed import DistributedSampler
+import json
+try:
+    from torch.utils.tensorboard import SummaryWriter
+except:
+    from tensorboardX import SummaryWriter
+
+from tqdm import tqdm, trange
+import multiprocessing
+from model import Model
+cpu_cont = multiprocessing.cpu_count()
+from transformers import (WEIGHTS_NAME, AdamW, get_linear_schedule_with_warmup,
+                          BertConfig, BertForMaskedLM, BertTokenizer, BertForSequenceClassification,
+                          GPT2Config, GPT2LMHeadModel, GPT2Tokenizer,
+                          OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer,
+                          RobertaConfig, RobertaForSequenceClassification, RobertaTokenizer,
+                          DistilBertConfig, DistilBertForMaskedLM, DistilBertForSequenceClassification, DistilBertTokenizer)
+
+logger = logging.getLogger(__name__)
+
+MODEL_CLASSES = {
+    'gpt2': (GPT2Config, GPT2LMHeadModel, GPT2Tokenizer),
+    'openai-gpt': (OpenAIGPTConfig, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer),
+    'bert': (BertConfig, BertForSequenceClassification, BertTokenizer),
+    'roberta': (RobertaConfig, RobertaForSequenceClassification, RobertaTokenizer),
+    'distilbert': (DistilBertConfig, DistilBertForSequenceClassification, DistilBertTokenizer)
+}
+
+
+
+class InputFeatures(object):
+    """A single training/test features for a example."""
+    def __init__(self,
+                 input_tokens,
+                 input_ids,
+                 idx,
+                 label,
+
+    ):
+        self.input_tokens = input_tokens
+        self.input_ids = input_ids
+        self.idx=str(idx)
+        self.label=label
+
+        
+def convert_examples_to_features(js,tokenizer,args):
+    #source
+    code=' '.join(js['func'].split())
+    code_tokens=tokenizer.tokenize(code)[:args.block_size-2]
+    source_tokens =[tokenizer.cls_token]+code_tokens+[tokenizer.sep_token]
+    source_ids =  tokenizer.convert_tokens_to_ids(source_tokens)
+    padding_length = args.block_size - len(source_ids)
+    source_ids+=[tokenizer.pad_token_id]*padding_length
+    return InputFeatures(source_tokens,source_ids,js['idx'],js['target'])
+
+class TextDataset(Dataset):
+    def __init__(self, tokenizer, args, file_path=None):
+        self.examples = []
+        with open(file_path) as f:
+            for line in f:
+                js=json.loads(line.strip())
+                self.examples.append(convert_examples_to_features(js,tokenizer,args))
+        if 'train' in file_path:
+            for idx, example in enumerate(self.examples[:3]):
+                    logger.info("*** Example ***")
+                    logger.info("idx: {}".format(idx))
+                    logger.info("label: {}".format(example.label))
+                    logger.info("input_tokens: {}".format([x.replace('\u0120','_') for x in example.input_tokens]))
+                    logger.info("input_ids: {}".format(' '.join(map(str, example.input_ids))))
+
+    def __len__(self):
+        return len(self.examples)
+
+    def __getitem__(self, i):       
+        return torch.tensor(self.examples[i].input_ids),torch.tensor(self.examples[i].label)
+            
+
+def set_seed(seed=42):
+    random.seed(seed)
+    os.environ['PYHTONHASHSEED'] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.backends.cudnn.deterministic = True
+
+
+def train(args, train_dataset, model, tokenizer):
+    """ Train the model """ 
+    args.train_batch_size = args.per_gpu_train_batch_size * max(1, args.n_gpu)
+    train_sampler = RandomSampler(train_dataset) if args.local_rank == -1 else DistributedSampler(train_dataset)
+    
+    train_dataloader = DataLoader(train_dataset, sampler=train_sampler, 
+                                  batch_size=args.train_batch_size,num_workers=4,pin_memory=True)
+    args.max_steps=args.epoch*len( train_dataloader)
+    args.save_steps=len( train_dataloader)
+    args.warmup_steps=len( train_dataloader)
+    args.logging_steps=len( train_dataloader)
+    args.num_train_epochs=args.epoch
+    model.to(args.device)
+    # 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.max_steps*0.1,
+                                                num_training_steps=args.max_steps)
+    if args.fp16:
+        try:
+            from apex import amp
+        except ImportError:
+            raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
+        model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)
+
+    # multi-gpu training (should be after apex fp16 initialization)
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Distributed training (should be after apex fp16 initialization)
+    if args.local_rank != -1:
+        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank],
+                                                          output_device=args.local_rank,
+                                                          find_unused_parameters=True)
+
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    scheduler_last = os.path.join(checkpoint_last, 'scheduler.pt')
+    optimizer_last = os.path.join(checkpoint_last, 'optimizer.pt')
+    if os.path.exists(scheduler_last):
+        scheduler.load_state_dict(torch.load(scheduler_last))
+    if os.path.exists(optimizer_last):
+        optimizer.load_state_dict(torch.load(optimizer_last))
+    # Train!
+    logger.info("***** Running training *****")
+    logger.info("  Num examples = %d", len(train_dataset))
+    logger.info("  Num Epochs = %d", args.num_train_epochs)
+    logger.info("  Instantaneous batch size per GPU = %d", args.per_gpu_train_batch_size)
+    logger.info("  Total train batch size (w. parallel, distributed & accumulation) = %d",
+                args.train_batch_size * args.gradient_accumulation_steps * (
+                    torch.distributed.get_world_size() if args.local_rank != -1 else 1))
+    logger.info("  Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
+    logger.info("  Total optimization steps = %d", args.max_steps)
+    
+    global_step = args.start_step
+    tr_loss, logging_loss,avg_loss,tr_nb,tr_num,train_loss = 0.0, 0.0,0.0,0,0,0
+    best_mrr=0.0
+    best_acc=0.0
+    # model.resize_token_embeddings(len(tokenizer))
+    model.zero_grad()
+
+    # Initialize early stopping parameters at the start of training
+    early_stopping_counter = 0
+    best_loss = None
+ 
+    for idx in range(args.start_epoch, int(args.num_train_epochs)): 
+        bar = tqdm(train_dataloader,total=len(train_dataloader))
+        tr_num=0
+        train_loss=0
+        for step, batch in enumerate(bar):
+            inputs = batch[0].to(args.device)        
+            labels=batch[1].to(args.device) 
+            model.train()
+            loss,logits = model(inputs,labels)
+
+
+            if args.n_gpu > 1:
+                loss = loss.mean()  # mean() to average on multi-gpu parallel training
+            if args.gradient_accumulation_steps > 1:
+                loss = loss / args.gradient_accumulation_steps
+
+            if args.fp16:
+                with amp.scale_loss(loss, optimizer) as scaled_loss:
+                    scaled_loss.backward()
+                torch.nn.utils.clip_grad_norm_(amp.master_params(optimizer), args.max_grad_norm)
+            else:
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
+
+            tr_loss += loss.item()
+            tr_num+=1
+            train_loss+=loss.item()
+            if avg_loss==0:
+                avg_loss=tr_loss
+            avg_loss=round(train_loss/tr_num,5)
+            bar.set_description("epoch {} loss {}".format(idx,avg_loss))
+
+                
+            if (step + 1) % args.gradient_accumulation_steps == 0:
+                optimizer.step()
+                optimizer.zero_grad()
+                scheduler.step()  
+                global_step += 1
+                output_flag=True
+                avg_loss=round(np.exp((tr_loss - logging_loss) /(global_step- tr_nb)),4)
+                if args.local_rank in [-1, 0] and args.logging_steps > 0 and global_step % args.logging_steps == 0:
+                    logging_loss = tr_loss
+                    tr_nb=global_step
+
+                if args.local_rank in [-1, 0] and args.save_steps > 0 and global_step % args.save_steps == 0:
+                    
+                    if args.local_rank == -1 and args.evaluate_during_training:  # Only evaluate when single GPU otherwise metrics may not average well
+                        results = evaluate(args, model, tokenizer,eval_when_training=True)
+                        for key, value in results.items():
+                            logger.info("  %s = %s", key, round(value,4))                    
+                        # Save model checkpoint
+                        
+                    if results['eval_acc']>best_acc:
+                        best_acc=results['eval_acc']
+                        logger.info("  "+"*"*20)  
+                        logger.info("  Best acc:%s",round(best_acc,4))
+                        logger.info("  "+"*"*20)                          
+                        
+                        checkpoint_prefix = 'checkpoint-best-acc'
+                        output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))                        
+                        if not os.path.exists(output_dir):
+                            os.makedirs(output_dir)                        
+                        model_to_save = model.module if hasattr(model,'module') else model
+                        output_dir = os.path.join(output_dir, '{}'.format('model.bin')) 
+                        torch.save(model_to_save.state_dict(), output_dir)
+                        logger.info("Saving model checkpoint to %s", output_dir)
+
+        # 每一轮记录checkpoint
+        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)
+
+        # Calculate average loss for the epoch
+        avg_loss = train_loss / tr_num
+
+        # Check for early stopping condition
+        if args.early_stopping_patience is not None:
+            if best_loss is None or avg_loss < best_loss - args.min_loss_delta:
+                best_loss = avg_loss
+                early_stopping_counter = 0
+            else:
+                early_stopping_counter += 1
+                if early_stopping_counter >= args.early_stopping_patience:
+                    logger.info("Early stopping")
+                    break  # Exit the loop early
+                        
+
+
+
+def evaluate(args, model, tokenizer,eval_when_training=False):
+    # Loop to handle MNLI double evaluation (matched, mis-matched)
+    eval_output_dir = args.output_dir
+
+    eval_dataset = TextDataset(tokenizer, args,args.eval_data_file)
+
+    if not os.path.exists(eval_output_dir) and args.local_rank in [-1, 0]:
+        os.makedirs(eval_output_dir)
+
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    # Note that DistributedSampler samples randomly
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size,num_workers=4,pin_memory=True)
+
+    # multi-gpu evaluate
+    if args.n_gpu > 1 and eval_when_training is False:
+        model = torch.nn.DataParallel(model)
+
+    # Eval!
+    logger.info("***** Running evaluation *****")
+    logger.info("  Num examples = %d", len(eval_dataset))
+    logger.info("  Batch size = %d", args.eval_batch_size)
+    eval_loss = 0.0
+    nb_eval_steps = 0
+    model.eval()
+    logits=[] 
+    labels=[]
+    for batch in eval_dataloader:
+        inputs = batch[0].to(args.device)        
+        label=batch[1].to(args.device) 
+        with torch.no_grad():
+            lm_loss,logit = model(inputs,label)
+            eval_loss += lm_loss.mean().item()
+            logits.append(logit.cpu().numpy())
+            labels.append(label.cpu().numpy())
+        nb_eval_steps += 1
+    logits=np.concatenate(logits,0)
+    labels=np.concatenate(labels,0)
+    preds=logits[:,0]>0.5
+    eval_acc=np.mean(labels==preds)
+    eval_loss = eval_loss / nb_eval_steps
+    perplexity = torch.tensor(eval_loss)
+            
+    result = {
+        "eval_loss": float(perplexity),
+        "eval_acc":round(eval_acc,4),
+    }
+    return result
+
+def test(args, model, tokenizer):
+    # Loop to handle MNLI double evaluation (matched, mis-matched)
+    eval_dataset = TextDataset(tokenizer, args,args.test_data_file)
+
+
+    args.eval_batch_size = args.per_gpu_eval_batch_size * max(1, args.n_gpu)
+    # Note that DistributedSampler samples randomly
+    eval_sampler = SequentialSampler(eval_dataset) if args.local_rank == -1 else DistributedSampler(eval_dataset)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size)
+
+    # multi-gpu evaluate
+    if args.n_gpu > 1:
+        model = torch.nn.DataParallel(model)
+
+    # Eval!
+    logger.info("***** Running Test *****")
+    logger.info("  Num examples = %d", len(eval_dataset))
+    logger.info("  Batch size = %d", args.eval_batch_size)
+    eval_loss = 0.0
+    nb_eval_steps = 0
+    model.eval()
+    logits=[]   
+    labels=[]
+    for batch in tqdm(eval_dataloader,total=len(eval_dataloader)):
+        inputs = batch[0].to(args.device)        
+        label=batch[1].to(args.device) 
+        with torch.no_grad():
+            logit = model(inputs)
+            logits.append(logit.cpu().numpy())
+            labels.append(label.cpu().numpy())
+
+    logits=np.concatenate(logits,0)
+    labels=np.concatenate(labels,0)
+    preds=logits[:,0]>0.5
+    with open(os.path.join(args.output_dir,"predictions.txt"),'w') as f:
+        for example,pred in zip(eval_dataset.examples,preds):
+            if pred:
+                f.write(example.idx+'\t1\n')
+            else:
+                f.write(example.idx+'\t0\n')    
+    
+                        
+                        
+def main():
+    parser = argparse.ArgumentParser()
+
+    ## Required parameters
+    parser.add_argument("--train_data_file", default=None, type=str, required=True,
+                        help="The input training data file (a text file).")
+    parser.add_argument("--output_dir", default=None, type=str, required=True,
+                        help="The output directory where the model predictions and checkpoints will be written.")
+
+    ## Other parameters
+    parser.add_argument("--eval_data_file", default=None, type=str,
+                        help="An optional input evaluation data file to evaluate the perplexity on (a text file).")
+    parser.add_argument("--test_data_file", default=None, type=str,
+                        help="An optional input evaluation data file to evaluate the perplexity on (a text file).")
+                    
+    parser.add_argument("--model_type", default="bert", type=str,
+                        help="The model architecture to be fine-tuned.")
+    parser.add_argument("--model_name_or_path", default=None, type=str,
+                        help="The model checkpoint for weights initialization.")
+
+    parser.add_argument("--mlm", action='store_true',
+                        help="Train with masked-language modeling loss instead of language modeling.")
+    parser.add_argument("--mlm_probability", type=float, default=0.15,
+                        help="Ratio of tokens to mask for masked language modeling loss")
+
+    parser.add_argument("--config_name", default="", type=str,
+                        help="Optional pretrained config name or path if not the same as model_name_or_path")
+    parser.add_argument("--tokenizer_name", default="", type=str,
+                        help="Optional pretrained tokenizer name or path if not the same as model_name_or_path")
+    parser.add_argument("--cache_dir", default="", type=str,
+                        help="Optional directory to store the pre-trained models downloaded from s3 (instread of the default one)")
+    parser.add_argument("--block_size", default=-1, type=int,
+                        help="Optional input sequence length after tokenization."
+                             "The training dataset will be truncated in block of this size for training."
+                             "Default to the model max input length for single sentence inputs (take into account special tokens).")
+    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("--evaluate_during_training", action='store_true',
+                        help="Run evaluation during training at each logging step.")
+    parser.add_argument("--do_lower_case", action='store_true',
+                        help="Set this flag if you are using an uncased model.")
+
+    parser.add_argument("--train_batch_size", default=4, type=int,
+                        help="Batch size per GPU/CPU for training.")
+    parser.add_argument("--eval_batch_size", default=4, 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("--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=1.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("--warmup_steps", default=0, type=int,
+                        help="Linear warmup over warmup_steps.")
+
+    parser.add_argument('--logging_steps', type=int, default=50,
+                        help="Log every X updates steps.")
+    parser.add_argument('--save_steps', type=int, default=50,
+                        help="Save checkpoint every X updates steps.")
+    parser.add_argument('--save_total_limit', type=int, default=None,
+                        help='Limit the total amount of checkpoints, delete the older checkpoints in the output_dir, does not delete by default')
+    parser.add_argument("--eval_all_checkpoints", action='store_true',
+                        help="Evaluate all checkpoints starting with the same prefix as model_name_or_path ending and ending with step number")
+    parser.add_argument("--no_cuda", action='store_true',
+                        help="Avoid using CUDA when available")
+    parser.add_argument('--overwrite_output_dir', action='store_true',
+                        help="Overwrite the content of the output directory")
+    parser.add_argument('--overwrite_cache', action='store_true',
+                        help="Overwrite the cached training and evaluation sets")
+    parser.add_argument('--seed', type=int, default=42,
+                        help="random seed for initialization")
+    parser.add_argument('--epoch', type=int, default=42,
+                        help="random seed for initialization")
+    parser.add_argument('--fp16', action='store_true',
+                        help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit")
+    parser.add_argument('--fp16_opt_level', type=str, default='O1',
+                        help="For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
+                             "See details at https://nvidia.github.io/apex/amp.html")
+    parser.add_argument("--local_rank", type=int, default=-1,
+                        help="For distributed training: local_rank")
+    parser.add_argument('--server_ip', type=str, default='', help="For distant debugging.")
+    parser.add_argument('--server_port', type=str, default='', help="For distant debugging.")
+
+    # Add early stopping parameters and dropout probability parameters
+    parser.add_argument("--early_stopping_patience", type=int, default=None,
+                        help="Number of epochs with no improvement after which training will be stopped.")
+    parser.add_argument("--min_loss_delta", type=float, default=0.001,
+                        help="Minimum change in the loss required to qualify as an improvement.")
+    parser.add_argument('--dropout_probability', type=float, default=0, help='dropout probability')
+
+
+    
+
+    args = parser.parse_args()
+
+    # Setup distant debugging if needed
+    if args.server_ip and args.server_port:
+        # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
+        import ptvsd
+        print("Waiting for debugger attach")
+        ptvsd.enable_attach(address=(args.server_ip, args.server_port), redirect_output=True)
+        ptvsd.wait_for_attach()
+
+    # 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
+    args.device = device
+    args.per_gpu_train_batch_size=args.train_batch_size//args.n_gpu
+    args.per_gpu_eval_batch_size=args.eval_batch_size//args.n_gpu
+    # Setup logging
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s -   %(message)s',
+                        datefmt='%m/%d/%Y %H:%M:%S',
+                        level=logging.INFO if args.local_rank in [-1, 0] else logging.WARN)
+    logger.warning("Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
+                   args.local_rank, device, args.n_gpu, bool(args.local_rank != -1), args.fp16)
+
+
+
+    # Set seed
+    set_seed(args.seed)
+
+    # Load pretrained model and tokenizer
+    if args.local_rank not in [-1, 0]:
+        torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training download model & vocab
+
+    args.start_epoch = 0
+    args.start_step = 0
+    checkpoint_last = os.path.join(args.output_dir, 'checkpoint-last')
+    if os.path.exists(checkpoint_last) and os.listdir(checkpoint_last):
+        args.model_name_or_path = os.path.join(checkpoint_last, 'pytorch_model.bin')
+        args.config_name = os.path.join(checkpoint_last, 'config.json')
+        idx_file = os.path.join(checkpoint_last, 'idx_file.txt')
+        with open(idx_file, encoding='utf-8') as idxf:
+            args.start_epoch = int(idxf.readlines()[0].strip()) + 1
+
+        step_file = os.path.join(checkpoint_last, 'step_file.txt')
+        if os.path.exists(step_file):
+            with open(step_file, encoding='utf-8') as stepf:
+                args.start_step = int(stepf.readlines()[0].strip())
+
+        logger.info("reload model from {}, resume from {} epoch".format(checkpoint_last, args.start_epoch))
+
+    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,
+                                          cache_dir=args.cache_dir if args.cache_dir else None)
+    config.num_labels=1
+    tokenizer = tokenizer_class.from_pretrained(args.tokenizer_name,
+                                                do_lower_case=args.do_lower_case,
+                                                cache_dir=args.cache_dir if args.cache_dir else None)
+    if args.block_size <= 0:
+        args.block_size = tokenizer.max_len_single_sentence  # Our input block size will be the max possible for the model
+    args.block_size = min(args.block_size, tokenizer.max_len_single_sentence)
+    if args.model_name_or_path:
+        model = model_class.from_pretrained(args.model_name_or_path,
+                                            from_tf=bool('.ckpt' in args.model_name_or_path),
+                                            config=config,
+                                            cache_dir=args.cache_dir if args.cache_dir else None)    
+    else:
+        model = model_class(config)
+
+    model=Model(model,config,tokenizer,args)
+    if args.local_rank == 0:
+        torch.distributed.barrier()  # End of barrier to make sure only the first process in distributed training download model & vocab
+
+    logger.info("Training/evaluation parameters %s", args)
+
+    # Training
+    if args.do_train:
+        if args.local_rank not in [-1, 0]:
+            torch.distributed.barrier()  # Barrier to make sure only the first process in distributed training process the dataset, and the others will use the cache
+
+        train_dataset = TextDataset(tokenizer, args,args.train_data_file)
+        if args.local_rank == 0:
+            torch.distributed.barrier()
+
+        train(args, train_dataset, model, tokenizer)
+
+
+
+    # Evaluation
+    results = {}
+    if args.do_eval and args.local_rank in [-1, 0]:
+            checkpoint_prefix = 'epoch_5/subject_model.pth'
+            output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))  
+            model.load_state_dict(torch.load(output_dir))      
+            model.to(args.device)
+            result=evaluate(args, model, tokenizer)
+            logger.info("***** Eval results *****")
+            for key in sorted(result.keys()):
+                logger.info("  %s = %s", key, str(round(result[key],4)))
+            
+    if args.do_test and args.local_rank in [-1, 0]:
+            checkpoint_prefix = 'epoch_5/subject_model.pth'
+            output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))  
+            model.load_state_dict(torch.load(output_dir))                  
+            model.to(args.device)
+            test(args, model, tokenizer)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()
+
+

Code-Code/Defect-detection/code/train.sh

@@ -0,0 +1,17 @@
+CUDA_VISIBLE_DEVICES=0,1  python run.py \
+    --output_dir=../model \
+    --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 400 \
+    --train_batch_size 32 \
+    --eval_batch_size 64 \
+    --learning_rate 2e-5 \
+    --max_grad_norm 1.0 \
+    --evaluate_during_training \
+    --seed 123456

Code-Code/Defect-detection/dataset.zip

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

Code-Code/Defect-detection/model/epoch_1/subject_model.pth

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

Code-Code/Defect-detection/model/epoch_2/subject_model.pth

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

Code-Code/Defect-detection/model/epoch_3/subject_model.pth

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

Code-Code/Defect-detection/model/epoch_4/subject_model.pth

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

Code-Code/Defect-detection/model/epoch_5/subject_model.pth

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

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