| |
| |
| 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]) |
|
|
