| import numpy as np
|
| import random
|
| import re
|
| import copy
|
| from nltk.corpus import stopwords
|
| import nltk
|
| pos_tag = nltk.pos_tag
|
| from nltk.stem import WordNetLemmatizer
|
| lemma = WordNetLemmatizer().lemmatize
|
| import sys
|
|
|
| function_word = [".", ",", "!", "?", "male", "female", "neutral"]
|
| def get_avail_phrases():
|
| sw = set(stopwords.words('english'))
|
| avail_phrases = set()
|
| fin = open("./conceptnet_entity.csv", 'r')
|
| for i, line in enumerate(fin):
|
| avail_phrases.add(' '.join(line.strip().split("|||")[:-1]))
|
| avail_phrases = avail_phrases - sw
|
| fin.close()
|
|
|
| fin = open("./negation.txt", 'r')
|
| negation_word = []
|
| for i, line in enumerate(fin):
|
| word = ' '.join(line.strip().split()[1:])
|
| negation_word.append(word)
|
| avail_phrases.add(word)
|
| fin.close()
|
|
|
| for w in function_word:
|
| avail_phrases.add(w)
|
|
|
| with open("avail_phrases.txt", "w") as fout:
|
| for w in avail_phrases:
|
| fout.write(w+"\n")
|
| return avail_phrases, negation_word
|
|
|
| avail_phrases, negation_word = get_avail_phrases()
|
|
|
| def output(st, fout):
|
| if "w" in data_dir:
|
| fout.write(" ".join(st)+"\n")
|
| else:
|
| for sen in st:
|
| fout.write(sen+"\n")
|
| fout.write("-"*5+"\n")
|
|
|
| def repeat_sentence(st):
|
|
|
| idx = np.random.choice(np.arange(len(st))[1:], 1 + int(len(st)/2), replace=False).tolist()
|
| s = min(idx)
|
| tmp_st = copy.deepcopy(st)
|
| for l in idx:
|
| tmp_st[l] = copy.deepcopy(tmp_st[s])
|
| return tmp_st
|
|
|
| def repeat_ngram(st):
|
|
|
| def repeat_sen_gram(st):
|
| flag = True
|
| for _ in range(10):
|
| try:
|
| idx = np.random.choice(np.arange(len(st))[1:])
|
| gram_num = np.random.choice(np.arange(5)[1:])
|
| split_sen = st[idx].strip().split()
|
| pointer_st = np.random.choice(np.arange(len(split_sen)))
|
| pointer_ed = pointer_st + gram_num
|
| if pointer_ed > len(split_sen):
|
| pointer_ed = pointer_st
|
| pointer_st = pointer_ed - gram_num
|
| if pointer_st < 0:
|
| continue
|
| else:
|
| flag = False
|
| break
|
| except:
|
| continue
|
| if flag:
|
| return copy.deepcopy(st)
|
| sen1, sen2, sen3 = " ".join(split_sen[:pointer_st]), " ".join(split_sen[pointer_st:pointer_ed]), " ".join(split_sen[pointer_ed:])
|
| tmp_st = copy.deepcopy(st)
|
| tmp_st[idx] = " ".join([sen1, sen2, sen2, sen3]).strip()
|
| return tmp_st
|
| for i in range(int(len(st)/2)):
|
| st = repeat_sen_gram(st)
|
| return st
|
|
|
| def replace_sentence(st):
|
| flag = True
|
| for _ in range(10):
|
| try:
|
| tmp_st = copy.deepcopy(st)
|
| idxs = np.random.choice(np.arange(len(st))[1:], np.random.choice(np.arange(1, len(st))), replace=False)
|
| replace_st_id = np.random.choice(np.arange(len(story)))
|
| for idx in idxs:
|
| tmp_st[idx] = np.random.choice(story[replace_st_id])
|
| flag = False
|
| break
|
| except:
|
| continue
|
| if flag:
|
| return copy.deepcopy(st)
|
| return tmp_st
|
|
|
| def change_neg_helper(sen):
|
| def pro(s):
|
| final_sen = " ".join(s)
|
| return final_sen
|
| sen = sen.strip().split()
|
| for i, n in enumerate(sen):
|
| if n in negation_word:
|
| del sen[i]
|
| return pro(sen)
|
| neg_list = ["not", "n't"]
|
| for i, n in enumerate(sen):
|
| if n in ["would", "will", "can", "could", "may", "might", "shall", "should", "do", "does", "did", "am", "is", "are", "was", "were", "be", "been"]:
|
| sen.insert(i+1, np.random.choice(neg_list))
|
| return pro(sen)
|
| pos_sen = pos_tag(sen)
|
| for i, n in enumerate(pos_sen):
|
| if n[1] == "VB":
|
| sen.insert(i, "do " + np.random.choice(neg_list))
|
| return pro(sen)
|
| elif n[1] == "VBD":
|
| sen[i] = lemma(sen[i], "v")
|
| sen.insert(i, "did " + np.random.choice(neg_list))
|
| return pro(sen)
|
| elif n[1] == "VBG":
|
| sen.insert(i, np.random.choice(neg_list))
|
| return pro(sen)
|
| elif n[1] == "VBN":
|
| sen.insert(i, np.random.choice(neg_list))
|
| return pro(sen)
|
| elif n[1] == "VBP":
|
| sen.insert(i, "do " + np.random.choice(neg_list))
|
| return pro(sen)
|
| elif n[1] == "VBZ":
|
| sen[i] = lemma(sen[i], "v")
|
| sen.insert(i, "does " + np.random.choice(neg_list))
|
| return pro(sen)
|
| print("VERB ERROR")
|
| return None
|
|
|
| anotomy_word = {}
|
| all_num, anotomy_num = 0, 0
|
| with open("./conceptnet_antonym.txt", "r") as fin:
|
| for line in fin:
|
| tmp = line.strip().split("|||")
|
| if len(tmp) == 3:
|
| h, t = tmp[0], tmp[2].split()
|
| if h in anotomy_word:
|
| anotomy_word[h] += t
|
| else:
|
| anotomy_word[h] = t[:]
|
|
|
| def change_neg_sentence(st):
|
| flag = True
|
| for _ in range(10):
|
| try:
|
| tmp_st = copy.deepcopy(st)
|
| idxs = np.random.choice(np.arange(len(st))[1:], np.random.choice(np.arange(1, len(st))), replace=False)
|
| for idx in idxs:
|
| tmp_st_idx = change_neg_helper(st[idx])
|
| if tmp_st_idx is not None:
|
| tmp_st[idx] = tmp_st_idx
|
| flag = False
|
| if flag == False:
|
| break
|
| except:
|
| continue
|
| if flag:
|
| return copy.deepcopy(st)
|
| return tmp_st
|
|
|
| def replace_word(st):
|
| global all_num, anotomy_num
|
| def replace_one_word(st):
|
| anotomy = False
|
| flag = True
|
| for _ in range(100):
|
| tmp_st = copy.deepcopy(st)
|
| idx = np.random.choice(np.arange(len(st))[1:])
|
| split_sen = tmp_st[idx].split()
|
| pos_split_sen = pos_tag(split_sen)
|
| avail_w_id = []
|
| for w_id, w in enumerate(split_sen):
|
| if (w in avail_phrases and w not in function_word and "[" not in w):
|
| avail_w_id.append(w_id)
|
| if len(avail_w_id) == 0: continue
|
| word_id = np.random.choice(avail_w_id)
|
| if pos_split_sen[word_id][1] not in pos_vocab_entity: continue
|
| lemma_word = lemma(pos_split_sen[word_id][0], 'v' if pos_split_sen[word_id][1][0] == 'V' else 'n')
|
| if lemma_word in anotomy_word:
|
| replace_word = np.random.choice(anotomy_word[lemma_word])
|
| anotomy = True
|
| else:
|
| word_freq = pos_vocab_entity[pos_split_sen[word_id][1]]
|
| replace_word = ""
|
| flag_in = True
|
| for _ in range(10):
|
| replace_word = np.random.choice(word_freq["word"], p=word_freq["freq"]/np.sum(word_freq["freq"]))
|
| if len(word_freq["word"]) == 1 or replace_word != pos_split_sen[word_id][0]:
|
| flag_in = False
|
| break
|
| if flag_in:
|
| replace_word = pos_split_sen[word_id][0]
|
| anotomy = False
|
| tmp_split_sen = copy.deepcopy(split_sen)
|
| split_sen[word_id] = replace_word
|
| tmp_st[idx] = " ".join(split_sen)
|
| flag = False
|
| break
|
| if flag:
|
| return copy.deepcopy(st), False
|
| return tmp_st, anotomy
|
| num = 0
|
| for idx in np.arange(len(st))[1:]:
|
| for word in st[idx].split():
|
| if word in avail_phrases:
|
| num += 1
|
| try:
|
| final_num = np.random.choice(np.arange(1, int(num*0.15+1)))
|
| except:
|
| final_num = 1
|
| for _ in range(final_num):
|
| st, anotomy = replace_one_word(st)
|
| all_num += 1
|
| if anotomy: anotomy_num += 1
|
| return st
|
|
|
| def shuffle_sentence(st, n_sentence):
|
| def exchange(l, ids, target_ids):
|
| tmp_l = copy.deepcopy(l)
|
| for o_id, t_id in zip(ids, target_ids):
|
| tmp_l[o_id] = copy.deepcopy(l[t_id])
|
| return tmp_l
|
|
|
| flag = True
|
| for _ in range(10):
|
| sen_ids = np.random.choice(np.arange(len(st))[1:], n_sentence, replace=False)
|
| target_ids = np.random.permutation(sen_ids)
|
| tmp_st = exchange(st, sen_ids, target_ids)
|
| if st != tmp_st:
|
| flag = False
|
| break
|
| if flag:
|
| return copy.deepcopy(st)
|
| return tmp_st
|
| def get_pos_vocab(dir):
|
| pos_vocab_entity = {}
|
| with open("%s/entity_vocab.txt"%dir, "r") as fin:
|
| for line in fin:
|
| tmp = line.strip().split("|||")
|
| word = tmp[0].split()[0]
|
| pos = tmp[1:]
|
| for p in pos:
|
| pp = p.split()
|
| if pp[0] in pos_vocab_entity:
|
| pos_vocab_entity[pp[0]]["word"].append(word)
|
| pos_vocab_entity[pp[0]]["freq"].append(float(pp[1]))
|
| else:
|
| pos_vocab_entity[pp[0]] = {"word":[word], "freq":[float(pp[1])]}
|
| return pos_vocab_entity
|
|
|
|
|
| name_list = ["test", "dev", "train"]
|
| data_dir = "./%s/ini_data"%("WritingPrompts" if "w" in sys.argv[1] else "ROCStories")
|
| output_dir = "%s/train_data"%("WritingPrompts" if "w" in sys.argv[1] else "ROCStories")
|
|
|
|
|
| type_dict = {"repeat":0.1, "replace":0.3, "shuffle":0.4, "neg":0.2}
|
| type_list = list(type_dict.keys())
|
| type_prob_list = []
|
| for t in type_list:
|
| type_prob_list.append(type_dict[t])
|
|
|
| time_list = [1,2,3,4]
|
|
|
| time_prob_list = [0.5,0.2,0.2,0.1]
|
|
|
| pos_vocab_entity = get_pos_vocab(data_dir)
|
| for name in name_list:
|
| if "w" in data_dir.lower():
|
| with open("%s/%s.wp_source"%(data_dir, name), "r") as fin1:
|
| with open("%s/%s.wp_target"%(data_dir, name), "r") as fin2:
|
| story, tmp = [], []
|
| for k, line in enumerate(fin2):
|
| src = fin1.readline().strip()
|
| if src[-1].isalpha():
|
| src = src + " ."
|
| tmp.append(src)
|
| for sen in line.strip().split(".")[:-1]:
|
| if sen.strip() != "":
|
| tmp.append(sen.strip()+" .")
|
| if len(tmp) >= 4:
|
| story.append(tmp)
|
| tmp = []
|
| else:
|
| with open("%s/%s.txt"%(data_dir, name), "r") as fin:
|
| story, tmp = [], []
|
| for k, line in enumerate(fin):
|
| i = k + 1
|
| if i % 6 == 0:
|
| story.append(tmp)
|
| tmp = []
|
| else:
|
| sen = line.strip()
|
| tmp.append(sen+" ." if sen[-1].isalpha() else sen)
|
|
|
| with open("%s/%s_human.txt"%(output_dir, name), "w") as fout:
|
| for st_id, st in enumerate(story):
|
| output(st, fout)
|
|
|
| prefix = "%s/%s_negative"%(output_dir, name)
|
| with open("%s.txt"%(prefix), "w") as fout:
|
| for st_id, st in enumerate(story):
|
| chaotic_list = np.random.choice(type_list,
|
| np.random.choice(time_list, p=time_prob_list), replace=False, p=type_prob_list/np.sum(type_prob_list)).tolist()
|
| print(chaotic_list)
|
| for c in chaotic_list:
|
| if c == "repeat":
|
| if random.random() < 0.7:
|
| st = repeat_sentence(st)
|
| else:
|
| st = repeat_ngram(st)
|
| if c == "replace":
|
| if random.random() < 0.5:
|
|
|
| st = replace_sentence(st)
|
| else:
|
|
|
| st = replace_word(st)
|
| if c == "shuffle":
|
| n_sentence = int(np.random.choice(np.arange(1,len(st)-1)+1))
|
| st = shuffle_sentence(st, n_sentence)
|
| if c == "neg":
|
| st = change_neg_sentence(st)
|
| output(st, fout)
|
|
|
|
|
|
|
| print("Anotomy:", anotomy_num)
|
| print("All:", all_num)
|
|
|
|
|
