Datasets:
File size: 8,597 Bytes
e82a469 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 |
import re
import json, time, random, torch
from torch.utils.data import Dataset, DataLoader
from transformers import BertTokenizer, AutoTokenizer
# from chinesebert import ChineseBertForMaskedLM, ChineseBertTokenizerFast, ChineseBertConfig
from tqdm import tqdm
import jieba
# from nltk.corpus import stopwords
# from src.helper import *
from importlib import import_module
import pickle as pkl
import time
from datetime import timedelta
MAX_VOCAB_SIZE = 10000
UNK, PAD = '<UNK>', '<PAD>'
def token_to_index(token, config):
vocab = pkl.load(open(config.vocab_path, 'rb'))
# print(f"Vocab size: {len(vocab)}")
words_line = []
if len(token) < config.pad_size:
token.extend([PAD] * (config.pad_size - len(token)))
else:
token = token[:config.pad_size]
# word to id
for word in token:
words_line.append(vocab.get(word, vocab.get(UNK)))
return words_line
# 获取dirty_word的索引
def get_dirty_words(path):
with open(path, 'r') as f:
data = json.load(f)
dirty_words = list(data.values())
return dirty_words
def get_all_dirty_words(base_path):
all_dirty_words = []
paths = ["general.json", "LGBT.json", "region.json", "sexism.json", "racism.json"]
for i in paths:
all_dirty_words.append(get_dirty_words(base_path + i))
return all_dirty_words
def get_toxic_id(text_idx, toxic_ids, dirty_words, toxic_index):
for dirty_word in dirty_words:
for index, token in enumerate(text_idx):
if token == 0:
break
if token != dirty_word[0]: # 第一个字符不是dirty_word的词首
continue
else:
flag = 1
start_index = index
end_index = index+1
for i in range(len(dirty_word[1:])):
if end_index >= len(text_idx): # 越界
flag = 0
break
if text_idx[end_index] != dirty_word[1+i]: # 后续单词非dirty词
flag = 0
break
end_index += 1
if flag:
for dirty_index in range(start_index, end_index): # 对含脏词的span打上类别label
toxic_ids[dirty_index] = toxic_index
# print(toxic_ids)
return toxic_ids
def get_all_toxic_id(pad_size, text_idx, all_dirty_words):
toxic_ids = [0 for i in range(pad_size)]
for toxic_index, dirty_words in enumerate(all_dirty_words):
toxic_ids = get_toxic_id(text_idx, toxic_ids, dirty_words, toxic_index+1)
return toxic_ids
class Datasets(Dataset):
'''
The dataset based on Bert.
'''
def __init__(self, kwargs, data_name, add_special_tokens=True, not_test=True):
self.kwargs = kwargs
self.not_test = not_test
self.data_name = data_name
self.lexicon_base_path = kwargs.lexicon_path
self.max_tok_len = kwargs.pad_size
self.add_special_tokens = add_special_tokens
# self.tokenizer = BertTokenizer.from_pretrained('resources/scibert_scivocab_cased')
# self.tokenizer = BertTokenizer.from_pretrained(kwargs.model_name)
# BERT/Roberta
self.tokenizer = AutoTokenizer.from_pretrained(kwargs.model_name)
# ChineseBERT
# self.tokenizer = ChineseBertTokenizerFast.from_pretrained(kwargs.model_name)
# self.word2vec_path = kwargs.word2vec_path
with open(data_name, 'r') as f:
self.data_file = json.load(f)
self.preprocess_data()
def preprocess_data(self):
print('Preprocessing Data {} ...'.format(self.data_name))
# word2idx, embedding_matrix = load_word2vec_matrix(self.word2vec_path)
data_time_start=time.time()
all_dirty_words = get_all_dirty_words(self.lexicon_base_path)
for row in tqdm(self.data_file):
ori_text = row['content']
text = self.tokenizer(ori_text, add_special_tokens=self.add_special_tokens,
max_length=int(self.max_tok_len), padding='max_length', truncation=True)
# For BERT
row['text_idx'] = text['input_ids']
row['text_ids'] = text['token_type_ids']
row['text_mask'] = text['attention_mask']
row['toxic_ids'] = get_all_toxic_id(self.max_tok_len, row['text_idx'], all_dirty_words)
# for glove
# sub_text = re.sub(u"([^\u0030-\u0039\u0041-\u005a\u0061-\u007a])"," ",ori_text)
# text_token = [w for w in ori_text]
# row["text_token_ids"] = token_to_index(text_token, self.kwargs)
# row["text_token_len"] = len(row["text_token_ids"])
# row["text_token_ids"] = pad_token_seq(row["text_token_ids"], self.max_tok_len)
data_time_end = time.time()
print("... finished preprocessing cost {} ".format(data_time_end-data_time_start))
# def get_key(self, index):
# path = "data/label/level_" + str(index) + '.json'
# with open(path, 'r+') as file:
# content=file.read()
# key = json.loads(content)
# return key
# def convert_one_hot(self, data, one_hot, length):
# data_ = [0 for i in range(length)]
# for i in data:
# data_[one_hot[i]] = 1
# return data_
def __len__(self):
return len(self.data_file)
def __getitem__(self, idx, corpus=None):
row = self.data_file[idx]
sample = {
# For BERT
'text_idx': row['text_idx'], 'text_ids': row['text_ids'], 'text_mask': row['text_mask'], 'toxic_ids': row['toxic_ids'],
# For GloVe
# 'text_token_ids': row["text_token_ids"]
'toxic': row["toxic_one_hot"], 'toxic_type': row["toxic_type_one_hot"], 'expression': row["expression_one_hot"], 'target': row["target"]
}
# For label
# sample['label'] = row['label']
return sample
class Dataloader(DataLoader):
'''
A batch sampler of a dataset.
'''
def __init__(self, data, batch_size, shuffle=True, SEED=0):
self.data = data
self.batch_size = batch_size
self.shuffle = shuffle
self.SEED = SEED
random.seed(self.SEED)
self.indices = list(range(len(data)))
if shuffle:
random.shuffle(self.indices)
self.batch_num = 0
def __len__(self):
return int(len(self.data) / float(self.batch_size))
def num_batches(self):
return len(self.data) / float(self.batch_size)
def __iter__(self):
self.indices = list(range(len(self.data)))
if self.shuffle:
random.shuffle(self.indices)
return self
def __next__(self):
if self.indices != []:
idxs = self.indices[:self.batch_size]
batch = [self.data.__getitem__(i) for i in idxs]
self.indices = self.indices[self.batch_size:]
return batch
else:
raise StopIteration
def get(self):
self.reset()
return self.__next__()
def reset(self):
self.indices = list(range(len(self.data)))
if self.shuffle: random.shuffle(self.indices)
def to_tensor(batch):
'''
Convert a batch data into tensor
'''
args = {}
# For label
# args["label"] = torch.tensor([b['label'] for b in batch])
# For BERT
args['text_idx'] = torch.tensor([b['text_idx'] for b in batch])
args['text_ids'] = torch.tensor([b['text_ids'] for b in batch])
args['text_mask'] = torch.tensor([b['text_mask'] for b in batch])
args['toxic_ids'] = torch.tensor([b['toxic_ids'] for b in batch])
# For GloVe
# args['text_token_len'] = torch.tensor([b['text_token_len'] for b in batch])
# args['text_token_ids'] = torch.tensor([b['text_token_ids'] for b in batch])
args['toxic'] = torch.tensor([b['toxic'] for b in batch])
args['toxic_type'] = torch.tensor([b['toxic_type'] for b in batch])
args['expression'] = torch.tensor([b['expression'] for b in batch])
args['target'] = torch.tensor([b['target'] for b in batch])
return args
def get_time_dif(start_time):
"""获取已使用时间"""
end_time = time.time()
time_dif = end_time - start_time
return timedelta(seconds=int(round(time_dif)))
def convert_onehot(config, label):
onehot_label = [0 for i in range(config.num_classes)]
onehot_label[int(label)] = 1
return onehot_label
|