add text-to-code

Text-code/text-to-code/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] == self._eos:
+                    beamLk[i] = -1e20
+        else:
+            beamLk = wordLk[0]
+        flatBeamLk = beamLk.view(-1)
+        bestScores, bestScoresId = flatBeamLk.topk(self.size, 0, True, True)
+
+        self.scores = bestScores
+
+        # bestScoresId is flattened beam x word array, so calculate which
+        # word and beam each score came from
+        prevK = bestScoresId // numWords
+        self.prevKs.append(prevK)
+        self.nextYs.append((bestScoresId - prevK * numWords))
+
+
+        for i in range(self.nextYs[-1].size(0)):
+            if self.nextYs[-1][i] == self._eos:
+                s = self.scores[i]
+                self.finished.append((s, len(self.nextYs) - 1, i))
+
+        # End condition is when top-of-beam is EOS and no global score.
+        if self.nextYs[-1][0] == self._eos:
+            self.eosTop = True
+
+    def done(self):
+        return self.eosTop and len(self.finished) >=self.size
+
+    def getFinal(self):
+        if len(self.finished) == 0:
+            self.finished.append((self.scores[0], len(self.nextYs) - 1, 0))
+        self.finished.sort(key=lambda a: -a[0])
+        if len(self.finished) != self.size:
+            unfinished=[]
+            for i in range(self.nextYs[-1].size(0)):
+                if self.nextYs[-1][i] != self._eos:
+                    s = self.scores[i]
+                    unfinished.append((s, len(self.nextYs) - 1, i)) 
+            unfinished.sort(key=lambda a: -a[0])
+            self.finished+=unfinished[:self.size-len(self.finished)]
+        return self.finished[:self.size]
+
+    def getHyp(self, beam_res):
+        """
+        Walk back to construct the full hypothesis.
+        """
+        hyps=[]
+        for _,timestep, k in beam_res:
+            hyp = []
+            for j in range(len(self.prevKs[:timestep]) - 1, -1, -1):
+                hyp.append(self.nextYs[j+1][k])
+                k = self.prevKs[j][k]
+            hyps.append(hyp[::-1])
+        return hyps
+    
+    def buildTargetTokens(self, preds):
+        sentence=[]
+        for pred in preds:
+            tokens = []
+            for tok in pred:
+                if tok==self._eos:
+                    break
+                tokens.append(tok)
+            sentence.append(tokens)
+        return sentence

Text-code/text-to-code/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)

Text-code/text-to-code/code/dataset.py

@@ -0,0 +1,116 @@
+# 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
+
+try:
+    from torch.utils.tensorboard import SummaryWriter
+except:
+    from tensorboardX import SummaryWriter
+
+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 concodeDataset(Dataset):
+    def __init__(self, tokenizer, args, logger, file_type='train', block_size=512, mode='train'):
+        if args.local_rank==-1:
+            local_rank=0
+            world_size=1
+        else:
+            local_rank=args.local_rank
+            world_size=torch.distributed.get_world_size()
+
+        self.block_size = block_size
+        self.mode = mode
+
+        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 mode != 'test' and 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:
+                data = pickle.load(handle)
+                self.inputs = data['inputs']
+                self.token_labels = data['token_labels']
+
+        else:
+            self.inputs = []
+            self.token_labels = []
+
+            datafile = os.path.join(args.data_dir, f"{file_type}.json")
+            if file_type == 'train':
+                logger.warning("Creating features from dataset file at %s", datafile)
+            datas = open(datafile).readlines()
+
+            length = len(datas)
+            logger.info("Data size: %d"%(length))
+            for idx, x in enumerate(datas):
+                if idx % (length//10) == 0:
+                    percent = idx / (length//10) * 10
+                    logger.warning("Rank %d, load %d"%(local_rank, percent))
+                if idx % world_size != local_rank:
+                    continue
+                x = json.loads(x)
+                code = tokenizer.encode(x["code"])
+                nl = tokenizer.encode(x["nl"])
+
+                input_ids, input_labels = self.pad_and_get_mask(code, nl, tokenizer)
+                self.inputs.append(input_ids)
+                self.token_labels.append(input_labels)
+
+            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)
+            if mode != 'test':
+                with open(cached_file, 'wb') as handle:
+                    pickle.dump({'inputs': self.inputs, 'token_labels': self.token_labels}, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+    def pad_and_get_mask(self, code, nl, tokenizer):
+        if self.mode == 'test':
+            code = []
+        while (len(code) + len(nl) + 2 > self.block_size):
+            if (len(code) > len(nl)):
+                code = code[:-1]
+            else:
+                nl = nl[:-1]
+        if self.mode == 'train':
+            inputs = nl + [tokenizer.bos_token_id] + code + [tokenizer.eos_token_id]
+            labels = [1] * len(nl) + [2] * (len(code)+1) + [0]
+        else:
+            inputs = nl + [tokenizer.bos_token_id]
+            labels = [1] * len(nl) + [2]
+            return inputs, labels
+        assert len(inputs) <= self.block_size
+        pad_len = self.block_size - len(inputs)
+        inputs += [tokenizer.pad_token_id] * pad_len
+        labels += [0] * pad_len
+        assert len(inputs) == len(labels)
+        return inputs, labels
+
+
+    def __len__(self):
+        return len(self.inputs)
+
+    def __getitem__(self, item):
+        return torch.tensor(self.inputs[item]), torch.tensor(self.token_labels[item])

Text-code/text-to-code/code/eval.sh

@@ -0,0 +1,17 @@
+LANG=java
+DATADIR=../dataset
+OUTPUTDIR=../model
+PRETRAINDIR=../model/checkpoint-last
+LOGFILE=text2code_concode_eval.log
+
+CUDA_VISIBLE_DEVICES=2 python run.py \
+        --data_dir=$DATADIR \
+        --langs=$LANG \
+        --output_dir=$OUTPUTDIR \
+        --pretrain_dir=$PRETRAINDIR \
+        --log_file=$LOGFILE \
+        --model_type=gpt2 \
+        --block_size=512 \
+        --do_eval \
+        --logging_steps=100 \
+        --seed=42

Text-code/text-to-code/code/evaluator.py

@@ -0,0 +1,42 @@
+# Copyright (c) Microsoft Corporation. 
+# Licensed under the MIT license.
+import os
+import logging
+import argparse
+from bleu import _bleu
+import json
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+def main():
+    parser = argparse.ArgumentParser(description='Evaluate leaderboard predictions for code completion (line level).')
+    parser.add_argument('--answers', '-a', required=True, help="filename of the labels, in json 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 = len(gts)
+    EM = 0.0
+    with open("ground_truth.txt", "w") as wf:
+        for pred, gt in zip(preds, gts):
+            pred = pred.strip()
+            gt = json.loads(gt)["code"]
+            wf.write(gt+"\n")
+            if pred.split() == gt.split():
+                EM += 1
+
+    bleu_score = round(_bleu("ground_truth.txt", args.predictions), 2)
+    logger.info(f"BLEU: {bleu_score}, EM: {round(EM/total*100, 2)}")
+
+    try:
+        os.remove("ground_truth.txt")
+    except Exception:
+        pass
+
+if __name__ == "__main__":
+    main()

Text-code/text-to-code/code/run.py

@@ -0,0 +1,665 @@
+# 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.
+"""
+Text to code generation 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 concodeDataset
+from beam import Beam
+
+try:
+    from torch.utils.tensorboard import SummaryWriter
+except:
+    from tensorboardX import SummaryWriter
+
+from torch.nn import CrossEntropyLoss
+
+from bleu import _bleu
+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)
+
+logger = logging.getLogger(__name__)
+
+MODEL_CLASSES = {
+    'gpt2': (GPT2Config, GPT2LMHeadModel, 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):
+    dataset = concodeDataset(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(model, tokenizer):
+    model.config.bos_token_id = tokenizer.bos_token_id
+    model.config.eos_token_id = tokenizer.eos_token_id
+    model.config.pad_token_id = tokenizer.pad_token_id
+
+
+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)
+        tb_writer = SummaryWriter(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):
+        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,
+                                                          find_unused_parameters=True)
+
+    # 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,0
+    # model.resize_token_embeddings(len(tokenizer))
+    model.zero_grad()
+    set_seed(args)  # Added here for reproducibility (even between python 2 and 3)
+
+    best_bleu = 0.0
+ 
+    for idx in range(args.start_epoch, int(args.num_train_epochs)): 
+        for step, (batch, token_labels) in enumerate(train_dataloader):
+            inputs = batch.to(args.device)
+            attn_mask = torch.tensor(token_labels.clone().detach() != 0, dtype=torch.uint8, device=args.device)
+            loss_mask = torch.tensor(token_labels.clone().detach() == 2, dtype=torch.uint8, device=args.device)
+            model.train()
+            # outputs = model(inputs, attention_mask=attn_mask, labels=inputs, loss_mask=loss_mask)
+            # loss = outputs[0]
+            outputs = model(inputs, attention_mask=attn_mask)
+            logits = outputs[0]
+            labels = inputs
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss()
+            flatten_shift_loss_mask = loss_mask[..., :-1].contiguous().view(-1)
+            ids = torch.nonzero(flatten_shift_loss_mask).view(-1)
+            loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1))[ids], shift_labels.view(-1)[ids])
+
+            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", global_step, round(avg_loss,5))
+                if args.local_rank in [-1, 0] and args.logging_steps > 0 and global_step % args.logging_steps == 0:
+                    # Log metrics
+                    tb_writer.add_scalar('lr', scheduler.get_last_lr()[0], global_step)
+                    tb_writer.add_scalar('loss', (tr_loss - logging_loss) / args.logging_steps, global_step)
+                    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():
+                            tb_writer.add_scalar('eval_{}'.format(key), value, global_step)
+                            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)))
+                        # dev_bleu, dev_EM = eval_bleu(args, model, tokenizer, file_type='dev', num=100)
+                        # logger.info(f"dev bleu: {dev_bleu}, dev EM: {dev_EM}")
+                        # output_dir = os.path.join(args.output_dir, '{}-{}-{}'.format(checkpoint_prefix, global_step, round(dev_bleu,2)))
+                        # if dev_bleu > best_bleu:
+                        #     best_bleu = dev_bleu
+                        #     logger.info(f"best bleu updated. saved in {output_dir}")
+                        #     logger.info(f"best bleu: {best_bleu}")
+                    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
+                    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)
+                    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')
+
+                    # torch.save(optimizer.state_dict(), os.path.join(output_dir, "optimizer.pt"))
+                    # torch.save(scheduler.state_dict(), os.path.join(output_dir, "scheduler.pt"))
+                    # logger.info("Saving optimizer and scheduler states to %s", output_dir)
+                    
+
+            if args.max_steps > 0 and global_step > args.max_steps:
+                break
+        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.local_rank in [-1, 0]:
+        tb_writer.close()
+
+    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)
+    eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size)
+
+    # 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 step, (batch, token_labels) in enumerate(eval_dataloader):
+
+        inputs = batch.to(args.device)
+        attn_mask = torch.tensor(token_labels.clone().detach() != 0, dtype=torch.uint8, device=args.device)
+        loss_mask = torch.tensor(token_labels.clone().detach() == 2, dtype=torch.uint8, device=args.device)
+        with torch.no_grad():
+            outputs = model(inputs, attention_mask=attn_mask)
+            logits = outputs[0]
+            labels = inputs
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss()
+            flatten_shift_loss_mask = loss_mask[..., :-1].contiguous().view(-1)
+            ids = torch.nonzero(flatten_shift_loss_mask).view(-1)
+            loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1))[ids], shift_labels.view(-1)[ids])
+            eval_loss += loss.mean().item()
+        nb_eval_steps += 1
+
+        # inputs = batch.to(args.device)
+        # attn_mask = torch.tensor(token_labels.clone().detach() != 0, dtype=torch.uint8, device=args.device)
+        # loss_mask = torch.tensor(token_labels.clone().detach() == 2, dtype=torch.uint8, device=args.device)
+        # with torch.no_grad():
+        #     outputs = model(inputs, attention_mask=attn_mask, labels=inputs, loss_mask=loss_mask)
+        #     loss = outputs[0]
+        #     eval_loss += 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_bleu(args, model, tokenizer, file_type='test', num=2000):
+    dataset = concodeDataset(tokenizer, args, logger, file_type=file_type, block_size=args.block_size, mode='test')
+    test_sampler = SequentialSampler(dataset)
+    test_dataloader = DataLoader(dataset, sampler=test_sampler, batch_size=1)
+    model.to(args.device)
+    model.zero_grad()
+    model.eval()
+
+    preds = []
+    max_gen_len = 100
+    for step, (batch, token_labels) in enumerate(test_dataloader):
+        if step >= num:
+            break
+        inputs = batch.to(args.device)
+        # with torch.no_grad():
+        #     outputs = model.generate(inputs, max_length=args.block_size, num_beams=10, temperature=0.7, early_stopping=False, top_k=70, \
+        #               bos_token_id=tokenizer.bos_token_id, eos_token_id=tokenizer.eos_token_id, pad_token_id=tokenizer.pad_token_id)
+        #     # outputs = model.generate(inputs, max_length=args.block_size, do_sample=True, temperature=0.7, top_k=70, top_p=0.95, \
+        #     #         bos_token_id=tokenizer.bos_token_id, eos_token_id=tokenizer.pad_token_id, pad_token_id=tokenizer.pad_token_id)
+        #     # outputs = model.generate(inputs, max_length=args.block_size, num_beams=10, temperature=0.7, early_stopping=False, top_k=70)
+        #     # outputs = model.generate(inputs, max_length=args.block_size, do_sample=True, temperature=0.7, top_k=70, top_p=0.95)
+        #     generation = tokenizer.decode(outputs[0])[len(tokenizer.decode(inputs[0])):]
+        #     preds.append(generation.rstrip("<pad>"))
+        
+        with torch.no_grad():
+            beam_size = 10
+            m = torch.nn.LogSoftmax(dim=-1)
+            outputs = model(inputs)[1]
+            p = []       
+            zero = torch.cuda.LongTensor(1).fill_(0)
+            for i in range(inputs.shape[0]):
+                # Compatible with transformers version 3.3.0 and 4.13.0
+                past = [torch.cat([x[0].unsqueeze(0),x[1].unsqueeze(0)],dim=0) if type(x)==tuple else x for x in outputs]
+                past_hidden = [x[:, i:i+1].expand(-1, beam_size, -1, -1, -1) for x in past]
+                # context_mask=source_mask[i:i+1,:].expand(beam_size,-1)
+                beam = Beam(beam_size, tokenizer.bos_token_id, tokenizer.eos_token_id)
+                input_ids = None
+                for _ in range(max_gen_len): 
+                    if beam.done():
+                        break
+                    input_ids = beam.getCurrentState()    
+                    # context_mask=torch.cat((context_mask,input_ids*0+1),-1)
+                    # mask=context_mask.unsqueeze(0).unsqueeze(-2).unsqueeze(-2).expand(self.config.n_layer, -1, -1, -1, -1)
+                    transformer_outputs = model(input_ids, past_key_values=past_hidden)
+                    out = m(transformer_outputs[0][:, -1, :]).data
+                    # out = self.lsm(self.lm_head(transformer_outputs[0][:,-1,:])).data
+                    beam.advance(out)
+                    past = [torch.cat([x[0].unsqueeze(0),x[1].unsqueeze(0)],dim=0) if type(x)==tuple else x for x in transformer_outputs[1]]
+                    past_hidden = [x.data.index_select(1, beam.getCurrentOrigin()) for x in past]
+                hyp = beam.getHyp(beam.getFinal())
+                pred  =beam.buildTargetTokens(hyp)[:beam_size]
+
+                pred = [torch.cat([x.view(-1) for x in p]+[zero]*(max_gen_len-len(p))).view(1,-1) for p in pred]
+                p.append(torch.cat(pred, 0).unsqueeze(0))
+            p = torch.cat(p, 0)
+            for pred in p:
+                t = pred[0].cpu().numpy()
+                t = list(t)
+                if 0 in t:
+                    t = t[:t.index(0)]
+                text = tokenizer.decode(t, clean_up_tokenization_spaces=False)
+                # print(text)
+                preds.append(text)
+        
+        if step % args.logging_steps == 0:
+            logger.info(f"{step} are done!")
+    
+    golds = []
+    datafile = os.path.join(args.data_dir, f"{file_type}.json")
+    datas = open(datafile).readlines()
+    for x in datas[:num]:
+        x = json.loads(x)
+        golds.append(x["code"])
+    
+    assert len(preds) == len(golds)
+
+    EM = []
+    with open(os.path.join(args.output_dir, f"{file_type}.output"), 'w') as f, open(os.path.join(args.output_dir, f"{file_type}.gold"), 'w') as f1:
+        for pred, gold in zip(preds, golds):
+            f.write(pred+'\n')
+            f1.write(gold+'\n')   
+            EM.append(pred.split() == gold.split())
+    
+    if file_type == "test":
+        return 0, 0
+
+    bleu_score = round(_bleu(os.path.join(args.output_dir, f"{file_type}.gold"), os.path.join(args.output_dir, f"{file_type}.output")), 2)
+    EM = round(np.mean(EM) * 100, 2)
+    return bleu_score, EM
+
+
+
+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("--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("--do_infer", action='store_true',
+                        help="Whether to run inference on test 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=2, type=int,
+                        help="Batch size per GPU/CPU for training.")
+    parser.add_argument("--per_gpu_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=10,
+                        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('--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.warning("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 {} epoch".format(checkpoint_last, args.start_epoch))
+
+    # Load pre-trained model
+    config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
+    pretrained = args.pretrain_dir
+    if pretrained:
+        tokenizer = tokenizer_class.from_pretrained(pretrained, do_lower_case=args.do_lower_case, bos_token='<s>', eos_token='</s>', pad_token='<pad>', unk_token='<|UNKNOWN|>', sep_token='concode_elem_sep')
+        logger.info(tokenizer.encode("<s> hello world <pad> </s>"))
+        model = model_class.from_pretrained(pretrained)
+        model.resize_token_embeddings(len(tokenizer))
+        update_config(model, tokenizer)
+        logger.info(model.config)
+    else:
+        tokenizer = tokenizer_class.from_pretrained(args.tokenizer_dir, bos_token='<s>', eos_token='</s>', pad_token='<pad>', unk_token='<|UNKNOWN|>', sep_token='concode_elem_sep')
+        args.vocab_size = tokenizer.vocab_size
+        config = config_class.from_pretrained(args.config_dir)
+        model = model_class(config)
+        model.resize_token_embeddings(len(tokenizer))
+        update_config(model, 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)
+
+    if args.do_eval:            # only works on 1 GPU
+        dev_bleu, dev_EM = eval_bleu(args, model, tokenizer, file_type='dev', num=2000)
+        logger.info(f"dev bleu: {dev_bleu}, dev EM: {dev_EM}")
+
+    if args.do_infer:            # only works on 1 GPU
+        test_bleu, test_EM = eval_bleu(args, model, tokenizer, file_type='test', num=2000)
+        logger.info(f"test bleu: {test_bleu}, test EM: {test_EM}")
+
+
+if __name__ == "__main__":
+    main()

Text-code/text-to-code/code/train.sh

@@ -0,0 +1,29 @@
+LANG=java
+DATADIR=../dataset
+OUTPUTDIR=../model
+PRETRAINDIR=microsoft/CodeGPT-small-java-adaptedGPT2    # will download pre-trained CodeGPT model
+LOGFILE=text2code_concode.log
+PER_NODE_GPU=2       # modify YOUR_GPU_NUM
+
+CUDA_VISIBLE_DEVICES=2,3 python run.py \
+        --data_dir=$DATADIR \
+        --langs=$LANG \
+        --output_dir=$OUTPUTDIR \
+        --pretrain_dir=$PRETRAINDIR \
+        --log_file=$LOGFILE \
+        --model_type=gpt2 \
+        --block_size=512 \
+        --do_train \
+        --node_index 0 \
+        --gpu_per_node $PER_NODE_GPU \
+        --learning_rate=5e-5 \
+        --weight_decay=0.01 \
+        --evaluate_during_training \
+        --per_gpu_train_batch_size=6 \
+        --per_gpu_eval_batch_size=12 \
+        --gradient_accumulation_steps=2 \
+        --num_train_epochs=30 \
+        --logging_steps=100 \
+        --save_steps=5000 \
+        --overwrite_output_dir \
+        --seed=42

Text-code/text-to-code/data.zip

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