def main(unused_argv):
if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if FLAGS.mode == "train":
os.makedirs(FLAGS.log_root)
else:
raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
tf.set_random_seed(6) # a seed value for randomness
cnn_classifier = CNN(config)
#cnn_batcher = ClaBatcher(hps_discriminator, vocab)
cnn_batcher = ClaBatcher(FLAGS, vocab)
sess_cnn, saver_cnn, train_dir_cnn = setup_training_classifier(cnn_classifier)
run_train_cnn_classifier(cnn_classifier, cnn_batcher, 15, sess_cnn, saver_cnn, train_dir_cnn)
#util.load_ckpt(saver_cnn, sess_cnn, ckpt_dir="train-classifier")
acc = run_test_classification(cnn_classifier, cnn_batcher, sess_cnn, saver_cnn, str('last'))
print("The accuracy of sentiment classifier is {:.3f}".format(acc))
generate_confident_examples(cnn_classifier, cnn_batcher, sess_cnn) ## train_conf
print("Start training emotional words detection model...")
model_class = Classification(FLAGS, vocab)
cla_batcher = AttenBatcher(FLAGS, vocab) # read from train_conf
sess_cls, saver_cls, train_dir_cls = setup_training_attention_classification(model_class)
run_train_attention_classification(model_class, cla_batcher, 15, sess_cls, saver_cls, train_dir_cls)
#util.load_ckpt(saver_cls, sess_cls, ckpt_dir="train-classification")
acc = run_test_classification(model_class, cla_batcher, sess_cls, saver_cls, str("final_acc"))
print("The sentiment classification accuracy of the emotional words detection model is {:.3f}".format(acc))
generated = Generate_training_sample(model_class, vocab, cla_batcher, sess_cls)
print("Generating training examples......")
generated.generate_training_example("train_filtered") #wirte train
generated.generator_valid_test_example("valid_test_filtered")
model = Seq2seq_AE(FLAGS, vocab)
# Create a batcher object that will create minibatches of data
batcher = GenBatcher(vocab, FLAGS) ##read from train
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
print("Start training generator......")
run_train_auto_encoder(model, batcher, 15, sess_ge, saver_ge, train_dir_ge, generated, cnn_classifier, sess_cnn, cla_batcher)
def main(unused_argv):
if len(unused_argv
) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(
tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if FLAGS.mode == "train":
os.makedirs(FLAGS.log_root)
else:
raise Exception(
"Logdir %s doesn't exist. Run in train mode to create it." %
(FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
# Make a namedtuple hps, containing the values of the hyperparameters that the model needs
hparam_list = [
'vocab_size', 'dataset', 'mode', 'lr', 'adagrad_init_acc',
'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm',
'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_sen_num',
'max_enc_num', 'max_dec_steps', 'max_enc_steps'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = [
'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std',
'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size',
'srl_max_dec_seq_len', 'srl_max_dec_sen_num', 'srl_max_enc_seq_len',
'srl_max_enc_sen_num'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_srl_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = [
'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std',
'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size',
'sc_max_dec_seq_len', 'sc_max_enc_seq_len'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_sc_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
# Create a batcher object that will create minibatches of data
sc_batcher = Sc_GenBatcher(vocab, hps_sc_generator)
tf.set_random_seed(111) # a seed value for randomness
if hps_generator.mode == 'train':
print("Start pre-training......")
sc_model = Sc_Generator(hps_sc_generator, vocab)
sess_sc, saver_sc, train_dir_sc = setup_training_sc_generator(sc_model)
sc_generated = Generated_sc_sample(sc_model, vocab, sess_sc)
print("Start pre-training generator......")
run_pre_train_sc_generator(sc_model, sc_batcher, 40, sess_sc, saver_sc,
train_dir_sc, sc_generated)
if not os.path.exists("data/" + str(0) + "/"):
os.mkdir("data/" + str(0) + "/")
sc_generated.generator_max_example_test(
sc_batcher.get_batches("pre-train"),
"data/" + str(0) + "/train_skeleton.txt")
sc_generated.generator_max_example_test(
sc_batcher.get_batches("pre-valid"),
"data/" + str(0) + "/valid_skeleton.txt")
sc_generated.generator_max_example_test(
sc_batcher.get_batches("pre-test"),
"data/" + str(0) + "/test_skeleton.txt")
merge("data/story/train_process.txt", "data/0/train_skeleton.txt",
"data/0/train.txt")
merge("data/story/validation_process.txt", "data/0/valid_skeleton.txt",
"data/0/valid.txt")
merge("data/story/test_process.txt", "data/0/test_skeleton.txt",
"data/0/test.txt")
#################################################################################################
batcher = GenBatcher(vocab, hps_generator)
srl_batcher = Srl_GenBatcher(vocab, hps_srl_generator)
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, sess_ge)
print("Start pre-training generator......")
run_pre_train_generator(model, batcher, 30, sess_ge, saver_ge,
train_dir_ge, generated)
##################################################################################################
srl_generator_model = Srl_Generator(hps_srl_generator, vocab)
sess_srl_ge, saver_srl_ge, train_dir_srl_ge = setup_training_srl_generator(
srl_generator_model)
util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
util.load_ckpt(saver_sc, sess_sc, ckpt_dir="train-sc-generator")
srl_generated = Generated_srl_sample(srl_generator_model, vocab,
sess_srl_ge)
whole_generated = Generated_whole_sample(model, srl_generator_model,
vocab, sess_ge, sess_srl_ge,
batcher, srl_batcher)
print("Start pre-training srl_generator......")
run_pre_train_srl_generator(srl_generator_model, batcher, srl_batcher,
20, sess_srl_ge, saver_srl_ge,
train_dir_srl_ge, srl_generated,
whole_generated)
loss_window = 0
t0 = time.time()
print("begin reinforcement learning:")
for epoch in range(10):
loss_window = 0.0
batcher = GenBatcher(vocab, hps_generator)
srl_batcher = Srl_GenBatcher(vocab, hps_srl_generator)
batches = batcher.get_batches(mode='train')
srl_batches = srl_batcher.get_batches(mode='train')
sc_batches = sc_batcher.get_batches(mode='train')
len_sc = len(sc_batches)
for i in range(min(len(batches), len(srl_batches))):
current_batch = batches[i]
current_srl_batch = srl_batches[i]
current_sc_batch = sc_batches[i % (len_sc - 1)]
results = model.run_pre_train_step(sess_ge, current_batch)
loss_list = results['without_average_loss']
example_skeleton_list = current_batch.original_review_outputs
example_text_list = current_batch.original_target_sentences
new_batch = sc_batcher.get_text_queue(example_skeleton_list,
example_text_list,
loss_list)
results_sc = sc_model.run_rl_train_step(sess_sc, new_batch)
loss = results_sc['loss']
loss_window += loss
results_srl = srl_generator_model.run_pre_train_step(
sess_srl_ge, current_srl_batch)
loss_list_srl = results_srl['without_average_loss']
example_srl_text_list = current_srl_batch.orig_outputs
example_skeleton_srl_list = current_srl_batch.orig_inputs
new_batch = sc_batcher.get_text_queue(
example_skeleton_srl_list, example_srl_text_list,
loss_list_srl)
results_sc = sc_model.run_rl_train_step(sess_sc, new_batch)
loss = results_sc['loss']
loss_window += loss
results_sc = sc_model.run_rl_train_step(
sess_sc, current_sc_batch)
loss = results_sc['loss']
loss_window += loss
train_step = results['global_step']
if train_step % 100 == 0:
t1 = time.time()
tf.logging.info(
'seconds for %d training generator step: %.3f ',
train_step, (t1 - t0) / 300)
t0 = time.time()
tf.logging.info('loss: %f', loss_window /
100) # print the loss to screen
loss_window = 0.0
train_srl_step = results_srl['global_step']
if train_srl_step % 10000 == 0:
saver_sc.save(sess_sc,
train_dir_sc + "/model",
global_step=results_sc['global_step'])
saver_ge.save(sess_ge,
train_dir_ge + "/model",
global_step=train_step)
saver_srl_ge.save(sess_srl_ge,
train_dir_srl_ge + "/model",
global_step=train_srl_step)
srl_generated.generator_max_example(
srl_batcher.get_batches("validation"),
"to_seq_max_generated/valid/" +
str(int(train_srl_step / 30000)) + "_positive",
"to_seq_max_generated/valid/" +
str(int(train_srl_step / 30000)) + "_negative")
srl_generated.generator_max_example(
srl_batcher.get_batches("test"),
"to_seq_max_generated/test/" +
str(int(train_srl_step / 30000)) + "_positive",
"to_seq_max_generated/test/" +
str(int(train_srl_step / 30000)) + "_negative")
whole_generated.generator_max_example(
batcher.get_batches("test-validation"),
"max_generated_final/valid/" +
str(int(train_srl_step / 30000)) + "_positive",
"max_generated_final/valid/" +
str(int(train_srl_step / 30000)) + "_negative")
whole_generated.generator_max_example(
batcher.get_batches("test-test"),
"max_generated_final/test/" +
str(int(train_srl_step / 30000)) + "_positive",
"max_generated_final/test/" +
str(int(train_srl_step / 30000)) + "_negative")
sc_generated.generator_max_example_test(
sc_batcher.get_batches("pre-train"),
"data/" + str(0) + "/train_skeleton.txt")
sc_generated.generator_max_example_test(
sc_batcher.get_batches("pre-valid"),
"data/" + str(0) + "/valid_skeleton.txt")
sc_generated.generator_max_example_test(
sc_batcher.get_batches("pre-test"),
"data/" + str(0) + "/test_skeleton.txt")
merge("data/story/train_process.txt", "data/0/train_skeleton.txt",
"data/0/train.txt")
merge("data/story/validation_process.txt",
"data/0/valid_skeleton.txt", "data/0/valid.txt")
merge("data/story/test_process.txt", "data/0/test_skeleton.txt",
"data/0/test.txt")
else:
raise ValueError("The 'mode' flag must be one of train/eval/decode")
def main(unused_argv):
# %%
# choose what level of logging you want
tf.logging.set_verbosity(tf.logging.INFO)
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# 創建字典
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size)
hparam_list = [
'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag',
'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim',
'batch_size', 'max_dec_sen_num', 'max_dec_steps', 'max_enc_steps'
]
hps_dict = {}
for key, val in FLAGS.__flags.items():
if key in hparam_list:
hps_dict[key] = val.value # add it to the dict
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = [
'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std',
'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size',
'max_enc_sen_num', 'max_enc_seq_len'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list:
hps_dict[key] = val.value # add it to the dict
hps_discriminator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
# # 取出最小batch size 的資料量
batcher = GenBatcher(vocab, hps_generator)
# print(batcher.train_batch[0].original_review_inputs)
# print(len(batcher.train_batch[0].original_review_inputs))
tf.set_random_seed(123)
# %%
if FLAGS.mode == 'train_generator':
# print("Start pre-training ......")
ge_model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(ge_model)
generated = Generated_sample(ge_model, vocab, batcher, sess_ge)
print("Start pre-training generator......")
run_pre_train_generator(ge_model, batcher, 300, sess_ge, saver_ge,
train_dir_ge)
# util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
print("finish load train-generator")
print("Generating negative examples......")
generator_graph = tf.Graph()
with generator_graph.as_default():
util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
print("finish load train-generator")
generated.generator_train_negative_example()
generated.generator_test_negative_example()
print("finish write")
elif FLAGS.mode == 'train_discriminator':
# print("Start pre-training ......")
model_dis = Discriminator(hps_discriminator, vocab)
dis_batcher = DisBatcher(hps_discriminator, vocab,
"discriminator_train/positive/*",
"discriminator_train/negative/*",
"discriminator_test/positive/*",
"discriminator_test/negative/*")
sess_dis, saver_dis, train_dir_dis = setup_training_discriminator(
model_dis)
print("Start pre-training discriminator......")
if not os.path.exists("discriminator_result"):
os.mkdir("discriminator_result")
run_pre_train_discriminator(model_dis, dis_batcher, 1000, sess_dis,
saver_dis, train_dir_dis)
elif FLAGS.mode == "adversarial_train":
generator_graph = tf.Graph()
discriminatorr_graph = tf.Graph()
print("Start adversarial-training......")
# tf.reset_default_graph()
with generator_graph.as_default():
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
print("finish load train-generator")
with discriminatorr_graph.as_default():
model_dis = Discriminator(hps_discriminator, vocab)
dis_batcher = DisBatcher(hps_discriminator, vocab,
"discriminator_train/positive/*",
"discriminator_train/negative/*",
"discriminator_test/positive/*",
"discriminator_test/negative/*")
sess_dis, saver_dis, train_dir_dis = setup_training_discriminator(
model_dis)
util.load_ckpt(saver_dis, sess_dis, ckpt_dir="train-discriminator")
print("finish load train-discriminator")
print("Start adversarial training......")
if not os.path.exists("train_sample_generated"):
os.mkdir("train_sample_generated")
if not os.path.exists("test_max_generated"):
os.mkdir("test_max_generated")
if not os.path.exists("test_sample_generated"):
os.mkdir("test_sample_generated")
whole_decay = False
for epoch in range(100):
print('開始訓練')
batches = batcher.get_batches(mode='train')
for step in range(int(len(batches) / 14)):
run_train_generator(model, model_dis, sess_dis, batcher,
dis_batcher,
batches[step * 14:(step + 1) * 14],
sess_ge, saver_ge, train_dir_ge)
generated.generator_sample_example(
"train_sample_generated/" + str(epoch) + "epoch_step" +
str(step) + "_temp_positive", "train_sample_generated/" +
str(epoch) + "epoch_step" + str(step) + "_temp_negative",
14)
tf.logging.info("test performance: ")
tf.logging.info("epoch: " + str(epoch) + " step: " + str(step))
# print("evaluate the diversity of DP-GAN (decode based on max probability)")
# generated.generator_test_sample_example(
# "test_sample_generated/" +
# str(epoch) + "epoch_step" + str(step) + "_temp_positive",
# "test_sample_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_negative", 14)
#
# print("evaluate the diversity of DP-GAN (decode based on sampling)")
# generated.generator_test_max_example(
# "test_max_generated/" +
# str(epoch) + "epoch_step" + str(step) + "_temp_positive",
# "test_max_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_negative", 14)
dis_batcher.train_queue = []
for i in range(epoch + 1):
for j in range(step + 1):
dis_batcher.train_queue += dis_batcher.fill_example_queue(
"train_sample_generated/" + str(i) + "epoch_step" +
str(j) + "_temp_positive/*")
dis_batcher.train_queue += dis_batcher.fill_example_queue(
"train_sample_generated/" + str(i) + "epoch_step" +
str(j) + "_temp_negative/*")
dis_batcher.train_batch = dis_batcher.create_batches(
mode="train", shuffleis=True)
whole_decay = run_train_discriminator(
model_dis, 5, dis_batcher,
dis_batcher.get_batches(mode="train"), sess_dis, saver_dis,
train_dir_dis, whole_decay)
elif FLAGS.mode == "test_language_model":
ge_model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(ge_model)
util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
print("finish load train-generator")
# generator_graph = tf.Graph()
# with generator_graph.as_default():
# util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
# print("finish load train-generator")
# jieba.load_userdict('dir.txt')
inputs = ''
while inputs != "close":
inputs = input("Enter your ask: ")
sentence = segmentor.segment(t2s.convert(inputs))
# sentence = jieba.cut(inputs)
sentence = (" ".join(sentence))
sentence = s2t.convert(sentence)
print(sentence)
sentence = sentence.split()
enc_input = [vocab.word2id(w) for w in sentence]
enc_lens = np.array([len(enc_input)])
enc_input = np.array([enc_input])
out_sentence = ('[START]').split()
dec_batch = [vocab.word2id(w) for w in out_sentence]
#dec_batch = [2] + dec_batch
# dec_batch.append(3)
while len(dec_batch) < 40:
dec_batch.append(1)
dec_batch = np.array([dec_batch])
dec_batch = np.resize(dec_batch, (1, 1, 40))
dec_lens = np.array([len(dec_batch)])
if (FLAGS.beamsearch == 'beamsearch_train'):
result = ge_model.run_test_language_model(
sess_ge, enc_input, enc_lens, dec_batch, dec_lens)
# print(result['generated'])
# print(result['generated'].shape)
output_ids = result['generated'][0]
decoded_words = data.outputids2words(output_ids, vocab, None)
print("decoded_words :", decoded_words)
else:
results = ge_model.run_test_beamsearch_example(
sess_ge, enc_input, enc_lens, dec_batch, dec_lens)
beamsearch_outputs = results['beamsearch_outputs']
for i in range(5):
predict_list = np.ndarray.tolist(beamsearch_outputs[:, :,
i])
predict_list = predict_list[0]
predict_seq = [vocab.id2word(idx) for idx in predict_list]
decoded_words = " ".join(predict_seq).split()
# decoded_words = decoded_words
try:
if decoded_words[0] == '[STOPDOC]':
decoded_words = decoded_words[1:]
# index of the (first) [STOP] symbol
fst_stop_idx = decoded_words.index(data.STOP_DECODING)
decoded_words = decoded_words[:fst_stop_idx]
except ValueError:
decoded_words = decoded_words
if decoded_words[-1] != '.' and decoded_words[
-1] != '!' and decoded_words[-1] != '?':
decoded_words.append('.')
decoded_words_all = []
decoded_output = ' '.join(
decoded_words).strip() # single string
decoded_words_all.append(decoded_output)
decoded_words_all = ' '.join(decoded_words_all).strip()
decoded_words_all = decoded_words_all.replace("[UNK] ", "")
decoded_words_all = decoded_words_all.replace("[UNK]", "")
decoded_words_all = decoded_words_all.replace(" ", "")
decoded_words_all, _ = re.subn(r"(! ){2,}", "",
decoded_words_all)
decoded_words_all, _ = re.subn(r"(\. ){2,}", "",
decoded_words_all)
if decoded_words_all.startswith('，'):
decoded_words_all = decoded_words_all[1:]
print("The resonse : {}".format(decoded_words_all))
def main(unused_argv):
if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if FLAGS.mode=="train":
os.makedirs(FLAGS.log_root)
else:
raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
# Make a namedtuple hps, containing the values of the hyperparameters that the model needs
hparam_list = ['mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_sen_num','max_dec_steps', 'max_enc_steps']
hps_dict = {}
for key,val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = ['lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm',
'hidden_dim', 'emb_dim', 'batch_size', 'max_enc_sen_num', 'max_enc_seq_len']
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_discriminator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
# Create a batcher object that will create minibatches of data
batcher = GenBatcher(vocab, hps_generator)
tf.set_random_seed(111) # a seed value for randomness
if hps_generator.mode == 'train':
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
print("Start pre-training generator......")
run_pre_train_generator(model, batcher, 10, sess_ge, saver_ge, train_dir_ge,generated) # this is an infinite loop until
print("Generating negetive examples......")
generated.generator_whole_negetive_example()
generated.generator_test_negetive_example()
model_dis = Discriminator(hps_discriminator, vocab)
dis_batcher = DisBatcher(hps_discriminator, vocab, "train/generated_samples_positive/*", "train/generated_samples_negetive/*", "test/generated_samples_positive/*", "test/generated_samples_negetive/*")
sess_dis, saver_dis, train_dir_dis = setup_training_discriminator(model_dis)
print("Start pre-training discriminator......")
#run_test_discriminator(model_dis, dis_batcher, sess_dis, saver_dis, "test")
run_pre_train_discriminator(model_dis, dis_batcher, 25, sess_dis, saver_dis, train_dir_dis)
util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
generated.generator_sample_example("sample_temp_positive", "sample_temp_negetive", 1000)
generated.generator_test_sample_example("test_sample_temp_positive",
"test_sample_temp_negetive",
200)
generated.generator_test_max_example("test_max_temp_positive",
"test_max_temp_negetive",
200)
tf.logging.info("true data diversity: ")
eva = Evaluate()
eva.diversity_evaluate("test_sample_temp_positive" + "/*")
print("Start adversial training......")
whole_decay = False
for epoch in range(1):
batches = batcher.get_batches(mode='train')
for step in range(int(len(batches)/1000)):
run_train_generator(model,model_dis,sess_dis,batcher,dis_batcher,batches[step*1000:(step+1)*1000],sess_ge, saver_ge, train_dir_ge,generated) #(model, discirminator_model, discriminator_sess, batcher, dis_batcher, batches, sess, saver, train_dir, generated):
generated.generator_sample_example("sample_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_positive", "sample_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_negetive", 1000)
#generated.generator_max_example("max_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_positive", "max_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_negetive", 200)
tf.logging.info("test performance: ")
tf.logging.info("epoch: "+str(epoch)+" step: "+str(step))
generated.generator_test_sample_example(
"test_sample_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_positive",
"test_sample_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_negetive", 200)
generated.generator_test_max_example("test_max_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_positive",
"test_max_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_negetive",
200)
dis_batcher.train_queue = []
dis_batcher.train_queue = []
for i in range(epoch+1):
for j in range(step+1):
dis_batcher.train_queue += dis_batcher.fill_example_queue("sample_generated/"+str(i)+"epoch_step"+str(j)+"_temp_positive/*")
dis_batcher.train_queue += dis_batcher.fill_example_queue("sample_generated/"+str(i)+"epoch_step"+str(j)+"_temp_negetive/*")
dis_batcher.train_batch = dis_batcher.create_batches(mode="train", shuffleis=True)
#dis_batcher.valid_batch = dis_batcher.train_batch
whole_decay = run_train_discriminator(model_dis, 5, dis_batcher, dis_batcher.get_batches(mode="train"),
sess_dis, saver_dis, train_dir_dis, whole_decay)
'''elif hps_generator.mode == 'decode':
decode_model_hps = hps_generator # This will be the hyperparameters for the decoder model
model = Generator(decode_model_hps, vocab)
generated = Generated_sample(model, vocab, batcher)
bleu_score = generated.compute_BLEU()'=
tf.logging.info('bleu: %f', bleu_score) # print the loss to screen'''
else:
def main(unused_argv):
if len(unused_argv
) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(
tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if FLAGS.mode == "train":
os.makedirs(FLAGS.log_root)
else:
raise Exception(
"Logdir %s doesn't exist. Run in train mode to create it." %
(FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
# Make a namedtuple hps, containing the values of the hyperparameters that the model needs
hparam_list = [
'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag',
'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim',
'batch_size', 'max_dec_steps', 'max_enc_steps'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = [
'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std',
'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_discriminator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
tf.set_random_seed(
111
) # a seed value for randomness # train-classification train-sentiment train-cnn-classificatin train-generator
if FLAGS.mode == "train-classifier":
#print("Start pre-training......")
model_class = Classification(hps_discriminator, vocab)
cla_batcher = ClaBatcher(hps_discriminator, vocab)
sess_cls, saver_cls, train_dir_cls = setup_training_classification(
model_class)
print("Start pre-training classification......")
run_pre_train_classification(model_class, cla_batcher, 1, sess_cls,
saver_cls, train_dir_cls) #10
generated = Generate_training_sample(model_class, vocab, cla_batcher,
sess_cls)
print("Generating training examples......")
generated.generate_training_example("train")
generated.generate_test_example("test")
elif FLAGS.mode == "train-sentimentor":
model_class = Classification(hps_discriminator, vocab)
cla_batcher = ClaBatcher(hps_discriminator, vocab)
sess_cls, saver_cls, train_dir_cls = setup_training_classification(
model_class)
print("Start pre_train_sentimentor......")
model_sentiment = Sentimentor(hps_generator, vocab)
sentiment_batcher = SenBatcher(hps_generator, vocab)
sess_sen, saver_sen, train_dir_sen = setup_training_sentimentor(
model_sentiment)
util.load_ckpt(saver_cls, sess_cls, ckpt_dir="train-classification")
run_pre_train_sentimentor(model_sentiment, sentiment_batcher, 1,
sess_sen, saver_sen, train_dir_sen) #1
elif FLAGS.mode == "test":
config = {
'n_epochs': 5,
'kernel_sizes': [3, 4, 5],
'dropout_rate': 0.5,
'val_split': 0.4,
'edim': 300,
'n_words': None, # Leave as none
'std_dev': 0.05,
'sentence_len': 50,
'n_filters': 100,
'batch_size': 50
}
config['n_words'] = 50000
cla_cnn_batcher = CNN_ClaBatcher(hps_discriminator, vocab)
cnn_classifier = CNN(config)
sess_cnn_cls, saver_cnn_cls, train_dir_cnn_cls = setup_training_cnnclassifier(
cnn_classifier)
#util.load_ckpt(saver_cnn_cls, sess_cnn_cls, ckpt_dir="train-cnnclassification")
run_train_cnn_classifier(cnn_classifier, cla_cnn_batcher, 1,
sess_cnn_cls, saver_cnn_cls,
train_dir_cnn_cls) #1
files = os.listdir("test-generate-transfer/")
for file_ in files:
run_test_our_method(cla_cnn_batcher, cnn_classifier, sess_cnn_cls,
"test-generate-transfer/" + file_ + "/*")
#elif FLAGS.mode == "test":
elif FLAGS.mode == "train-generator":
model_class = Classification(hps_discriminator, vocab)
cla_batcher = ClaBatcher(hps_discriminator, vocab)
sess_cls, saver_cls, train_dir_cls = setup_training_classification(
model_class)
model_sentiment = Sentimentor(hps_generator, vocab)
sentiment_batcher = SenBatcher(hps_generator, vocab)
sess_sen, saver_sen, train_dir_sen = setup_training_sentimentor(
model_sentiment)
config = {
'n_epochs': 5,
'kernel_sizes': [3, 4, 5],
'dropout_rate': 0.5,
'val_split': 0.4,
'edim': 300,
'n_words': None, # Leave as none
'std_dev': 0.05,
'sentence_len': 50,
'n_filters': 100,
'batch_size': 50
}
config['n_words'] = 50000
cla_cnn_batcher = CNN_ClaBatcher(hps_discriminator, vocab)
cnn_classifier = CNN(config)
sess_cnn_cls, saver_cnn_cls, train_dir_cnn_cls = setup_training_cnnclassifier(
cnn_classifier)
model = Generator(hps_generator, vocab)
batcher = GenBatcher(vocab, hps_generator)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
util.load_ckpt(saver_cnn_cls,
sess_cnn_cls,
ckpt_dir="train-cnnclassification")
util.load_ckpt(saver_sen, sess_sen, ckpt_dir="train-sentimentor")
generated = Generated_sample(model, vocab, batcher, sess_ge)
print("Start pre-training generator......")
run_pre_train_generator(model, batcher, 1, sess_ge, saver_ge,
train_dir_ge, generated, cla_cnn_batcher,
cnn_classifier, sess_cnn_cls) # 4
generated.generate_test_negetive_example(
"temp_negetive",
batcher) # batcher, model_class, sess_cls, cla_batcher
generated.generate_test_positive_example("temp_positive", batcher)
#run_test_our_method(cla_cnn_batcher, cnn_classifier, sess_cnn_cls,
# "temp_negetive" + "/*")
loss_window = 0
t0 = time.time()
print("begin reinforcement learning:")
for epoch in range(30):
batches = batcher.get_batches(mode='train')
for i in range(len(batches)):
current_batch = copy.deepcopy(batches[i])
sentiment_batch = batch_sentiment_batch(
current_batch, sentiment_batcher)
result = model_sentiment.max_generator(sess_sen,
sentiment_batch)
weight = result['generated']
current_batch.weight = weight
sentiment_batch.weight = weight
cla_batch = batch_classification_batch(current_batch, batcher,
cla_batcher)
result = model_class.run_ypred_auc(sess_cls, cla_batch)
cc = SmoothingFunction()
reward_sentiment = 1 - np.abs(0.5 - result['y_pred_auc'])
reward_BLEU = []
for k in range(FLAGS.batch_size):
reward_BLEU.append(
sentence_bleu(
[current_batch.original_reviews[k].split()],
cla_batch.original_reviews[k].split(),
smoothing_function=cc.method1))
reward_BLEU = np.array(reward_BLEU)
reward_de = (2 / (1.0 / (1e-6 + reward_sentiment) + 1.0 /
(1e-6 + reward_BLEU)))
result = model.run_train_step(sess_ge, current_batch)
train_step = result[
'global_step'] # we need this to update our running average loss
loss = result['loss']
loss_window += loss
if train_step % 100 == 0:
t1 = time.time()
tf.logging.info(
'seconds for %d training generator step: %.3f ',
train_step, (t1 - t0) / 100)
t0 = time.time()
tf.logging.info('loss: %f', loss_window /
100) # print the loss to screen
loss_window = 0.0
if train_step % 10000 == 0:
generated.generate_test_negetive_example(
"test-generate-transfer/" + str(epoch) + "epoch_step" +
str(train_step) + "_temp_positive", batcher)
generated.generate_test_positive_example(
"test-generate/" + str(epoch) + "epoch_step" +
str(train_step) + "_temp_positive", batcher)
#saver_ge.save(sess, train_dir + "/model", global_step=train_step)
#run_test_our_method(cla_cnn_batcher, cnn_classifier, sess_cnn_cls,
# "test-generate-transfer/" + str(epoch) + "epoch_step" + str(
# train_step) + "_temp_positive" + "/*")
cla_batch, bleu = output_to_classification_batch(
result['generated'], current_batch, batcher, cla_batcher,
cc)
result = model_class.run_ypred_auc(sess_cls, cla_batch)
reward_result_sentiment = result['y_pred_auc']
reward_result_bleu = np.array(bleu)
reward_result = (2 / (1.0 /
(1e-6 + reward_result_sentiment) + 1.0 /
(1e-6 + reward_result_bleu)))
current_batch.score = 1 - current_batch.score
result = model.max_generator(sess_ge, current_batch)
cla_batch, bleu = output_to_classification_batch(
result['generated'], current_batch, batcher, cla_batcher,
cc)
result = model_class.run_ypred_auc(sess_cls, cla_batch)
reward_result_transfer_sentiment = result['y_pred_auc']
reward_result_transfer_bleu = np.array(bleu)
reward_result_transfer = (
2 / (1.0 /
(1e-6 + reward_result_transfer_sentiment) + 1.0 /
(1e-6 + reward_result_transfer_bleu)))
#tf.logging.info("reward_nonsentiment: "+str(reward_sentiment) +" output_original_sentiment: "+str(reward_result_sentiment)+" output_original_bleu: "+str(reward_result_bleu))
reward = reward_result_transfer #reward_de + reward_result_sentiment +
#tf.logging.info("reward_de: "+str(reward_de))
model_sentiment.run_train_step(sess_sen, sentiment_batch,
reward)
def main(unused_argv):
if len(unused_argv
) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(
tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if "train" in FLAGS.mode:
os.makedirs(FLAGS.log_root)
else:
raise Exception(
"Logdir %s doesn't exist. Run in train mode to create it." %
(FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
# print('FLAGS.flag_values_dict() ->', FLAGS.flag_values_dict())
flags_dict = FLAGS.flag_values_dict()
# Make a namedtuple hps, containing the values of the hyperparameters that the model needs
hparam_list = [
'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag',
'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim',
'batch_size', 'max_dec_sen_num', 'max_dec_steps', 'max_enc_steps'
]
hps_dict = {}
for key, val in flags_dict.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
print('hps_dict ->', json.dumps(hps_dict, ensure_ascii=False))
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = [
'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std',
'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size',
'max_enc_sen_num', 'max_enc_seq_len'
]
hps_dict = {}
for key, val in flags_dict.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_discriminator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
# # test
# model_dis = Discriminator(hps_discriminator, vocab)
# model_dis.build_graph()
# sys.exit(0)
# # test
print('before load batcher...')
# Create a batcher object that will create minibatches of data
batcher = GenBatcher(vocab, hps_generator)
print('after load batcher...')
tf.set_random_seed(111) # a seed value for randomness
if hps_generator.mode == 'adversarial_train':
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
model_dis = Discriminator(hps_discriminator, vocab)
dis_batcher = DisBatcher(hps_discriminator, vocab,
"discriminator_train/positive/*",
"discriminator_train/negative/*",
"discriminator_test/positive/*",
"discriminator_test/negative/*")
sess_dis, saver_dis, train_dir_dis = setup_training_discriminator(
model_dis)
util.load_ckpt(saver_dis, sess_dis, ckpt_dir="train-discriminator")
util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
if not os.path.exists("MLE"): os.mkdir("MLE")
print("evaluate the diversity of MLE (decode based on sampling)")
generated.generator_test_sample_example("MLE/" + "MLE_sample_positive",
"MLE/" + "MLE_sample_negative",
200)
print(
"evaluate the diversity of MLE (decode based on max probability)")
generated.generator_test_max_example("MLE/" + "MLE_max_temp_positive",
"MLE/" + "MLE_max_temp_negative",
200)
print("Start adversarial training......")
if not os.path.exists("train_sample_generated"):
os.mkdir("train_sample_generated")
if not os.path.exists("test_max_generated"):
os.mkdir("test_max_generated")
if not os.path.exists("test_sample_generated"):
os.mkdir("test_sample_generated")
whole_decay = False
for epoch in range(10):
batches = batcher.get_batches(mode='train')
for step in range(int(len(batches) / 1000)):
run_train_generator(
model, model_dis, sess_dis, batcher, dis_batcher,
batches[step * 1000:(step + 1) * 1000], sess_ge, saver_ge,
train_dir_ge, generated
) # (model, discirminator_model, discriminator_sess, batcher, dis_batcher, batches, sess, saver, train_dir, generated):
generated.generator_sample_example(
"train_sample_generated/" + str(epoch) + "epoch_step" +
str(step) + "_temp_positive", "train_sample_generated/" +
str(epoch) + "epoch_step" + str(step) + "_temp_negative",
1000)
# generated.generator_max_example("max_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_positive", "max_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_negetive", 200)
tf.logging.info("test performance: ")
tf.logging.info("epoch: " + str(epoch) + " step: " + str(step))
print(
"evaluate the diversity of DP-GAN (decode based on max probability)"
)
generated.generator_test_sample_example(
"test_sample_generated/" + str(epoch) + "epoch_step" +
str(step) + "_temp_positive", "test_sample_generated/" +
str(epoch) + "epoch_step" + str(step) + "_temp_negative",
200)
print(
"evaluate the diversity of DP-GAN (decode based on sampling)"
)
generated.generator_test_max_example(
"test_max_generated/" + str(epoch) + "epoch_step" +
str(step) + "_temp_positive", "test_max_generated/" +
str(epoch) + "epoch_step" + str(step) + "_temp_negative",
200)
dis_batcher.train_queue = []
dis_batcher.train_queue = []
for i in range(epoch + 1):
for j in range(step + 1):
dis_batcher.train_queue += dis_batcher.fill_example_queue(
"train_sample_generated/" + str(i) + "epoch_step" +
str(j) + "_temp_positive/*")
dis_batcher.train_queue += dis_batcher.fill_example_queue(
"train_sample_generated/" + str(i) + "epoch_step" +
str(j) + "_temp_negative/*")
dis_batcher.train_batch = dis_batcher.create_batches(
mode="train", shuffleis=True)
# dis_batcher.valid_batch = dis_batcher.train_batch
whole_decay = run_train_discriminator(
model_dis, 5, dis_batcher,
dis_batcher.get_batches(mode="train"), sess_dis, saver_dis,
train_dir_dis, whole_decay)
elif hps_generator.mode == 'train_generator':
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
print("Start pre-training generator......")
# this is an infinite loop until
run_pre_train_generator(model, batcher, 10, sess_ge, saver_ge,
train_dir_ge, generated)
print("Generating negative examples......")
generated.generator_train_negative_example()
generated.generator_test_negative_example()
elif hps_generator.mode == 'train_discriminator':
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
# util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
model_dis = Discriminator(hps_discriminator, vocab)
dis_batcher = DisBatcher(hps_discriminator, vocab,
"discriminator_train/positive/*",
"discriminator_train/negative/*",
"discriminator_test/positive/*",
"discriminator_test/negative/*")
sess_dis, saver_dis, train_dir_dis = setup_training_discriminator(
model_dis)
print("Start pre-training discriminator......")
# run_test_discriminator(model_dis, dis_batcher, sess_dis, saver_dis, "test")
if not os.path.exists("discriminator_result"):
os.mkdir("discriminator_result")
run_pre_train_discriminator(model_dis, dis_batcher, 25, sess_dis,
saver_dis, train_dir_dis)
def main(unused_argv):
if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if FLAGS.mode == "train":
os.makedirs(FLAGS.log_root)
else:
raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
# Make a namedtuple hps, containing the values of the hyperparameters that the model needs
hparam_list = ['mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm',
'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps', 'max_enc_steps']
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = ['lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm',
'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps']
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_discriminator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
tf.set_random_seed(6) # a seed value for randomness
cnn_classifier = CNN(config)
cnn_batcher = ClaBatcher(hps_discriminator, vocab)
sess_cnn, saver_cnn, train_dir_cnn = setup_training_classifier(cnn_classifier)
run_train_cnn_classifier(cnn_classifier, cnn_batcher, 0, sess_cnn, saver_cnn, train_dir_cnn)
#util.load_ckpt(saver_cnn, sess_cnn, ckpt_dir="train-classifier")
acc = run_test_classification(cnn_classifier, cnn_batcher, sess_cnn, saver_cnn, str('last'))
print("the last stored cnn model acc = ", acc)
generate_confident_examples(cnn_classifier, cnn_batcher, sess_cnn) ## train_conf
print("Start pre-training attention classification......")
model_class = Classification(hps_discriminator, vocab)
cla_batcher = AttenBatcher(hps_discriminator, vocab) # read from train_conf
sess_cls, saver_cls, train_dir_cls = setup_training_classification(model_class)
run_pre_train_classification(model_class, cla_batcher, 0, sess_cls, saver_cls, train_dir_cls)
#util.load_ckpt(saver_cls, sess_cls, ckpt_dir="train-classification")
acc = run_test_classification(model_class, cla_batcher, sess_cls, saver_cls, str("final_acc"))
print("the last stored attention model acc = ", acc)
acc = run_test_classification(cnn_classifier, cla_batcher, sess_cnn, saver_cnn, str("final_acc"))
print("the last stored classifier model acc = ", acc)
generated = Generate_training_sample(model_class, vocab, cla_batcher, sess_cls)
print("Generating training examples......")
#generated.generate_training_example("train_filtered") #wirte train
#generated.generator_validation_example("valid_filtered")
#generated.generator_test_example("test_filtered")
model = Seq2seq_AE(hps_generator, vocab)
# Create a batcher object that will create minibatches of data
batcher = GenBatcher(vocab, hps_generator) ##read from train
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
print("Start pre-training generator......")
run_pre_train_auto_encoder(model, batcher, 0, sess_ge, saver_ge, train_dir_ge, generated, cnn_classifier, sess_cnn, cla_batcher)
def main(unused_argv):
if len(unused_argv) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if "train" in FLAGS.mode:
os.makedirs(FLAGS.log_root)
else:
raise Exception("Logdir %s doesn't exist. Run in train mode to create it." % (FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
# Make a namedtuple hps, containing the values of the hyperparameters that the model needs
hparam_list = ['mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_sen_num','max_dec_steps', 'max_enc_steps']
hps_dict = {}
for key,val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = ['lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std', 'max_grad_norm',
'hidden_dim', 'emb_dim', 'batch_size', 'max_enc_sen_num', 'max_enc_seq_len']
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_discriminator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
# Create a batcher object that will create minibatches of data
batcher = GenBatcher(vocab, hps_generator)
tf.set_random_seed(111) # a seed value for randomness
if hps_generator.mode == 'adversarial_train':
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
model_dis = Discriminator(hps_discriminator, vocab)
dis_batcher = DisBatcher(hps_discriminator, vocab, "discriminator_train/positive/*", "discriminator_train/negative/*", "discriminator_test/positive/*", "discriminator_test/negative/*")
sess_dis, saver_dis, train_dir_dis = setup_training_discriminator(model_dis)
util.load_ckpt(saver_dis, sess_dis, ckpt_dir="train-discriminator")
util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
if not os.path.exists("MLE"): os.mkdir("MLE")
print("evaluate the diversity of MLE (decode based on sampling)")
generated.generator_test_sample_example("MLE/"+"MLE_sample_positive",
"MLE/"+"MLE_sample_negative",
200)
print("evaluate the diversity of MLE (decode based on max probability)")
generated.generator_test_max_example("MLE/"+"MLE_max_temp_positive",
"MLE/"+"MLE_max_temp_negative",
200)
print("Start adversarial training......")
if not os.path.exists("train_sample_generated"): os.mkdir("train_sample_generated")
if not os.path.exists("test_max_generated"): os.mkdir("test_max_generated")
if not os.path.exists("test_sample_generated"): os.mkdir("test_sample_generated")
whole_decay = False
for epoch in range(10):
batches = batcher.get_batches(mode='train')
for step in range(int(len(batches)/1000)):
run_train_generator(model,model_dis,sess_dis,batcher,dis_batcher,batches[step*1000:(step+1)*1000],sess_ge, saver_ge, train_dir_ge,generated) #(model, discirminator_model, discriminator_sess, batcher, dis_batcher, batches, sess, saver, train_dir, generated):
generated.generator_sample_example("train_sample_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_positive", "train_sample_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_negative", 1000)
#generated.generator_max_example("max_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_positive", "max_generated/"+str(epoch)+"epoch_step"+str(step)+"_temp_negetive", 200)
tf.logging.info("test performance: ")
tf.logging.info("epoch: "+str(epoch)+" step: "+str(step))
print("evaluate the diversity of DP-GAN (decode based on max probability)")
generated.generator_test_sample_example(
"test_sample_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_positive",
"test_sample_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_negative", 200)
print("evaluate the diversity of DP-GAN (decode based on sampling)")
generated.generator_test_max_example("test_max_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_positive",
"test_max_generated/" + str(epoch) + "epoch_step" + str(step) + "_temp_negative",
200)
dis_batcher.train_queue = []
dis_batcher.train_queue = []
for i in range(epoch+1):
for j in range(step+1):
dis_batcher.train_queue += dis_batcher.fill_example_queue("train_sample_generated/"+str(i)+"epoch_step"+str(j)+"_temp_positive/*")
dis_batcher.train_queue += dis_batcher.fill_example_queue("train_sample_generated/"+str(i)+"epoch_step"+str(j)+"_temp_negative/*")
dis_batcher.train_batch = dis_batcher.create_batches(mode="train", shuffleis=True)
#dis_batcher.valid_batch = dis_batcher.train_batch
whole_decay = run_train_discriminator(model_dis, 5, dis_batcher, dis_batcher.get_batches(mode="train"),
sess_dis, saver_dis, train_dir_dis, whole_decay)
elif hps_generator.mode == 'train_generator':
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
generated = Generated_sample(model, vocab, batcher, sess_ge)
print("Start pre-training generator......")
run_pre_train_generator(model, batcher, 10, sess_ge, saver_ge, train_dir_ge,generated) # this is an infinite loop until
print("Generating negative examples......")
generated.generator_train_negative_example()
generated.generator_test_negative_example()
elif hps_generator.mode == 'train_discriminator':
print("Start pre-training......")
model = Generator(hps_generator, vocab)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
#util.load_ckpt(saver_ge, sess_ge, ckpt_dir="train-generator")
model_dis = Discriminator(hps_discriminator, vocab)
dis_batcher = DisBatcher(hps_discriminator, vocab, "discriminator_train/positive/*", "discriminator_train/negative/*", "discriminator_test/positive/*", "discriminator_test/negative/*")
sess_dis, saver_dis, train_dir_dis = setup_training_discriminator(model_dis)
print("Start pre-training discriminator......")
#run_test_discriminator(model_dis, dis_batcher, sess_dis, saver_dis, "test")
if not os.path.exists("discriminator_result"): os.mkdir("discriminator_result")
run_pre_train_discriminator(model_dis, dis_batcher, 25, sess_dis, saver_dis, train_dir_dis)
def main(unused_argv):
if len(unused_argv
) != 1: # prints a message if you've entered flags incorrectly
raise Exception("Problem with flags: %s" % unused_argv)
tf.logging.set_verbosity(
tf.logging.INFO) # choose what level of logging you want
tf.logging.info('Starting running in %s mode...', (FLAGS.mode))
# Change log_root to FLAGS.log_root/FLAGS.exp_name and create the dir if necessary
FLAGS.log_root = os.path.join(FLAGS.log_root, FLAGS.exp_name)
if not os.path.exists(FLAGS.log_root):
if FLAGS.mode == "train":
os.makedirs(FLAGS.log_root)
else:
raise Exception(
"Logdir %s doesn't exist. Run in train mode to create it." %
(FLAGS.log_root))
vocab = Vocab(FLAGS.vocab_path, FLAGS.vocab_size) # create a vocabulary
# Make a namedtuple hps, containing the values of the hyperparameters that the model needs
hparam_list = [
'mode', 'lr', 'adagrad_init_acc', 'rand_unif_init_mag',
'trunc_norm_init_std', 'max_grad_norm', 'hidden_dim', 'emb_dim',
'batch_size', 'max_dec_steps', 'max_enc_steps'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_generator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
hparam_list = [
'lr', 'adagrad_init_acc', 'rand_unif_init_mag', 'trunc_norm_init_std',
'max_grad_norm', 'hidden_dim', 'emb_dim', 'batch_size', 'max_dec_steps'
]
hps_dict = {}
for key, val in FLAGS.__flags.items(): # for each flag
if key in hparam_list: # if it's in the list
hps_dict[key] = val # add it to the dict
hps_discriminator = namedtuple("HParams", hps_dict.keys())(**hps_dict)
tf.set_random_seed(111) # a seed value for randomness
if hps_generator.mode == 'train':
print("Start pre-training......")
model_class = Classification(hps_discriminator, vocab)
cla_batcher = ClaBatcher(hps_discriminator, vocab)
sess_cls, saver_cls, train_dir_cls = setup_training_classification(
model_class)
print("Start pre-training classification......")
#run_pre_train_classification(model_class, cla_batcher, 10, sess_cls, saver_cls, train_dir_cls)
#generated = Generate_training_sample(model_class, vocab, cla_batcher, sess_cls)
#print("Generating training examples......")
#generated.generate_training_example("train")
#generated.generator_validation_example("valid")
model_sentiment = Sentimentor(hps_generator, vocab)
sentiment_batcher = SenBatcher(hps_generator, vocab)
sess_sen, saver_sen, train_dir_sen = setup_training_sentimentor(
model_sentiment)
#run_pre_train_sentimentor(model_sentiment,sentiment_batcher,1,sess_sen,saver_sen,train_dir_sen)
sentiment_generated = Generate_non_sentiment_weight(
model_sentiment, vocab, sentiment_batcher, sess_sen)
#sentiment_generated.generate_training_example("train_sentiment")
#sentiment_generated.generator_validation_example("valid_sentiment")
model = Generator(hps_generator, vocab)
# Create a batcher object that will create minibatches of data
batcher = GenBatcher(vocab, hps_generator)
sess_ge, saver_ge, train_dir_ge = setup_training_generator(model)
util.load_ckpt(saver_sen, sess_sen, ckpt_dir="train-sentimentor")
util.load_ckpt(saver_cls, sess_cls, ckpt_dir="train-classification")
generated = Generated_sample(model, vocab, batcher, sess_ge)
#print("Start pre-training generator......")
run_pre_train_generator(
model, batcher, 4, sess_ge, saver_ge, train_dir_ge, generated,
model_class, sess_cls,
cla_batcher) # this is an infinite loop until interrupted
#generated.generator_validation_negetive_example("temp_negetive", batcher, model_class,sess_cls,cla_batcher) # batcher, model_class, sess_cls, cla_batcher
#generated.generator_validation_positive_example(
# "temp_positive", batcher, model_class,sess_cls,cla_batcher)
loss_window = 0
t0 = time.time()
print("begin dual learning:")
for epoch in range(30):
batches = batcher.get_batches(mode='train')
for i in range(len(batches)):
current_batch = copy.deepcopy(batches[i])
sentiment_batch = batch_sentiment_batch(
current_batch, sentiment_batcher)
result = model_sentiment.max_generator(sess_sen,
sentiment_batch)
weight = result['generated']
current_batch.weight = weight
sentiment_batch.weight = weight
cla_batch = batch_classification_batch(current_batch, batcher,
cla_batcher)
result = model_class.run_ypred_auc(sess_cls, cla_batch)
cc = SmoothingFunction()
reward_sentiment = 1 - np.abs(0.5 - result['y_pred_auc'])
reward_BLEU = []
for k in range(FLAGS.batch_size):
reward_BLEU.append(
sentence_bleu(
[current_batch.original_reviews[k].split()],
cla_batch.original_reviews[k].split(),
smoothing_function=cc.method1))
reward_BLEU = np.array(reward_BLEU)
reward_de = (2 / (1.0 / (1e-6 + reward_sentiment) + 1.0 /
(1e-6 + reward_BLEU)))
result = model.run_train_step(sess_ge, current_batch)
train_step = result[
'global_step'] # we need this to update our running average loss
loss = result['loss']
loss_window += loss
if train_step % 100 == 0:
t1 = time.time()
tf.logging.info(
'seconds for %d training generator step: %.3f ',
train_step, (t1 - t0) / 100)
t0 = time.time()
tf.logging.info('loss: %f', loss_window /
100) # print the loss to screen
loss_window = 0.0
if train_step % 10000 == 0:
#bleu_score = generatored.compute_BLEU(str(train_step))
#tf.logging.info('bleu: %f', bleu_score) # print the loss to screen
generated.generator_validation_negetive_example(
"valid-generated-transfer/" + str(epoch) +
"epoch_step" + str(train_step) + "_temp_positive",
batcher, model_class, sess_cls, cla_batcher)
generated.generator_validation_positive_example(
"valid-generated/" + str(epoch) + "epoch_step" +
str(train_step) + "_temp_positive", batcher,
model_class, sess_cls, cla_batcher)
#saver_ge.save(sess, train_dir + "/model", global_step=train_step)
cla_batch, bleu = output_to_classification_batch(
result['generated'], current_batch, batcher, cla_batcher,
cc)
result = model_class.run_ypred_auc(sess_cls, cla_batch)
reward_result_sentiment = result['y_pred_auc']
reward_result_bleu = np.array(bleu)
reward_result = (2 / (1.0 /
(1e-6 + reward_result_sentiment) + 1.0 /
(1e-6 + reward_result_bleu)))
current_batch.score = 1 - current_batch.score
result = model.max_generator(sess_ge, current_batch)
cla_batch, bleu = output_to_classification_batch(
result['generated'], current_batch, batcher, cla_batcher,
cc)
result = model_class.run_ypred_auc(sess_cls, cla_batch)
reward_result_transfer_sentiment = result['y_pred_auc']
reward_result_transfer_bleu = np.array(bleu)
reward_result_transfer = (
2 / (1.0 /
(1e-6 + reward_result_transfer_sentiment) + 1.0 /
(1e-6 + reward_result_transfer_bleu)))
#tf.logging.info("reward_nonsentiment: "+str(reward_sentiment) +" output_original_sentiment: "+str(reward_result_sentiment)+" output_original_bleu: "+str(reward_result_bleu))
reward = reward_result_transfer #reward_de + reward_result_sentiment +
#tf.logging.info("reward_de: "+str(reward_de))
model_sentiment.run_train_step(sess_sen, sentiment_batch,
reward)
elif hps_generator.mode == 'decode':
decode_model_hps = hps_generator # This will be the hyperparameters for the decoder model
#model = Generator(decode_model_hps, vocab)
#generated = Generated_sample(model, vocab, batcher)
#bleu_score = generated.compute_BLEU()
#tf.logging.info('bleu: %f', bleu_score) # print the loss to screen
else:
raise ValueError("The 'mode' flag must be one of train/eval/decode")
