def init_real_trainng(self, data_loc=None): from utils.text_process import text_precess, text_to_code from utils.text_process import get_tokenlized, get_word_list, get_dict if data_loc is None: data_loc = 'data/image_coco.txt' self.sequence_length, self.vocab_size = text_precess(data_loc) generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, emb_dim=self.emb_dim, hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, start_token=self.start_token) self.set_generator(generator) discriminator = Discriminator(sequence_length=self.sequence_length, num_classes=2, vocab_size=self.vocab_size, emd_dim=self.emb_dim, filter_sizes=self.filter_size, num_filters=self.num_filters, l2_reg_lambda=self.l2_reg_lambda) self.set_discriminator(discriminator) gen_dataloader = DataLoader(batch_size=self.batch_size, seq_length=self.sequence_length) oracle_dataloader = None dis_dataloader = DisDataloader(batch_size=self.batch_size, seq_length=self.sequence_length) self.set_data_loader(gen_loader=gen_dataloader, dis_loader=dis_dataloader, oracle_loader=oracle_dataloader) tokens = get_tokenlized(data_loc) word_set = get_word_list(tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(self.oracle_file, 'w') as outfile: outfile.write(text_to_code(tokens, word_index_dict, self.sequence_length)) return word_index_dict, index_word_dict
def init_real_trainng(self, data_loc=None): from utils.text_process import text_precess, text_to_code from utils.text_process import get_tokenlized, get_word_list, get_dict if data_loc is None: data_loc = 'data/image_coco.txt' self.sequence_length, self.vocab_size = text_precess(data_loc) g_embeddings = tf.Variable( tf.random.normal(shape=[self.vocab_size, self.emb_dim], stddev=0.1)) discriminator = Discriminator(sequence_length=self.sequence_length, num_classes=2, emd_dim=self.emb_dim, filter_sizes=self.filter_size, num_filters=self.num_filters, g_embeddings=g_embeddings, l2_reg_lambda=self.l2_reg_lambda) self.set_discriminator(discriminator) generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, emb_dim=self.emb_dim, hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, g_embeddings=g_embeddings, discriminator=discriminator, start_token=self.start_token) self.set_generator(generator) gen_dataloader = DataLoader(batch_size=self.batch_size, seq_length=self.sequence_length) oracle_dataloader = None dis_dataloader = DisDataloader(batch_size=self.batch_size, seq_length=self.sequence_length) self.set_data_loader(gen_loader=gen_dataloader, dis_loader=dis_dataloader, oracle_loader=oracle_dataloader) tokens = get_tokenlized(data_loc) word_set = get_word_list(tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(self.oracle_file, 'w') as outfile: outfile.write( text_to_code(tokens, word_index_dict, self.sequence_length)) return word_index_dict, index_word_dict
def init_real_trainng(self, data_loc=None): from utils.text_process import text_precess, text_to_code from utils.text_process import get_tokenlized, get_word_list, get_dict if data_loc is None: data_loc = 'data/image_coco.txt' self.sequence_length, self.vocab_size = text_precess(data_loc) generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, emb_dim=self.emb_dim, hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, start_token=self.start_token) self.set_generator(generator) discriminator = Discriminator(sequence_length=self.sequence_length, num_classes=2, vocab_size=self.vocab_size, emd_dim=self.emb_dim, filter_sizes=self.filter_size, num_filters=self.num_filters, l2_reg_lambda=self.l2_reg_lambda) self.set_discriminator(discriminator) # 创建dataloader gen_dataloader = DataLoader(batch_size=self.batch_size, seq_length=self.sequence_length) # 这时真实文本就使用现实中的文本 oracle_dataloader = None dis_dataloader = DisDataloader(batch_size=self.batch_size, seq_length=self.sequence_length) # data pipe工作在这里完成!!!!!!!!!11 self.set_data_loader(gen_loader=gen_dataloader, dis_loader=dis_dataloader, oracle_loader=oracle_dataloader) tokens = get_tokenlized(data_loc) word_set = get_word_list(tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(self.oracle_file, 'w') as outfile: # 这里把oracle_file给编码了 outfile.write( text_to_code(tokens, word_index_dict, self.sequence_length)) return word_index_dict, index_word_dict
def init_real_trainng(self, data_loc=None): from utils.text_process import text_precess, text_to_code from utils.text_process import get_tokenlized, get_word_list, get_dict if data_loc is None: data_loc = 'data/image_coco.txt' self.sequence_length, self.vocab_size = text_precess(data_loc) generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, emb_dim=self.emb_dim, hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, start_token=self.start_token) self.set_generator(generator) gen_dataloader = DataLoader(batch_size=self.batch_size, seq_length=self.sequence_length) oracle_dataloader = None dis_dataloader = None self.set_data_loader(gen_loader=gen_dataloader, dis_loader=dis_dataloader, oracle_loader=oracle_dataloader) tokens = get_tokenlized(data_loc) word_set = get_word_list(tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(self.oracle_file, 'w') as outfile: outfile.write(text_to_code(tokens, word_index_dict, self.sequence_length)) return word_index_dict, index_word_dict
def init_real_trainng(self, data_loc=None): from utils.text_process import coco_process, coco_text_to_code from utils.text_process import get_tokenlized, get_word_list, get_dict, split_text if data_loc is None: data_loc = 'data/image_coco.txt' self.sequence_length, self.vocab_size = coco_process(data_loc) featloader = FeatLoader(self.feat_json, self.feat_mmp) generator = Generator(num_vocabulary=self.vocab_size, batch_size=self.batch_size, emb_dim=self.emb_dim, hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, start_token=self.start_token, featloader=featloader) self.set_generator(generator) discriminator = Discriminator(sequence_length=self.sequence_length, num_classes=2, vocab_size=self.vocab_size, emd_dim=self.emb_dim, filter_sizes=self.filter_size, num_filters=self.num_filters, l2_reg_lambda=self.l2_reg_lambda) self.set_discriminator(discriminator) for var in tf.trainable_variables(): tf.summary.histogram("parameters/" + var.op.name, var) gen_dataloader = DataLoader(batch_size=self.batch_size, seq_length=self.sequence_length, featloader=featloader) oracle_dataloader = None dis_dataloader = DisDataloader(batch_size=self.batch_size, seq_length=self.sequence_length, featloader=featloader) self.set_data_loader(gen_loader=gen_dataloader, dis_loader=dis_dataloader, oracle_loader=oracle_dataloader) tokens = get_tokenlized(data_loc) img_ids, tokens = split_text(tokens) word_set = get_word_list(tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(self.dict_file, 'w') as outfile: json.dump({'iw': index_word_dict, 'wi': word_index_dict}, outfile) with open(self.oracle_file, 'w') as outfile: outfile.write(coco_text_to_code(img_ids, tokens, word_index_dict, self.sequence_length)) return word_index_dict, index_word_dict
def main(): print('program start') from utils.text_process import text_precess, text_to_code # TODO: move? from utils.text_process import get_tokenlized, get_word_list, get_dict random.seed(SEED) np.random.seed(SEED) assert START_TOKEN == 0 # JJ added SEQ_LENGTH, vocab_size = text_precess(true_file, val_file) gen_data_loader = Gen_Data_loader(BATCH_SIZE, SEQ_LENGTH) gan_data_loader = Gen_Data_loader(BATCH_SIZE, SEQ_LENGTH) val_data_loader = Gen_Data_loader(BATCH_SIZE, SEQ_LENGTH) likelihood_data_loader = Gen_Data_loader(BATCH_SIZE, SEQ_LENGTH) # For testing #vocab_size = 5000 # JJ added # Create training file and dicts tokens = get_tokenlized(true_file) val_tokens = get_tokenlized(val_file) word_set = get_word_list(tokens + val_tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(oracle_file, 'w') as outfile: outfile.write(text_to_code(tokens, word_index_dict, SEQ_LENGTH)) with open(val_oracle_file, 'w') as outfile: outfile.write(text_to_code(val_tokens, word_index_dict, SEQ_LENGTH)) generator = Generator(vocab_size, BATCH_SIZE, EMB_DIM, HIDDEN_DIM, SEQ_LENGTH, START_TOKEN) #target_params = pickle.load(open('save/target_params_py3.pkl', 'rb')) #target_lstm = TARGET_LSTM(vocab_size, BATCH_SIZE, 32, 32, SEQ_LENGTH, START_TOKEN, target_params) # The oracle model mediator = Mediator(vocab_size, BATCH_SIZE, EMB_DIM * 2, HIDDEN_DIM * 2, SEQ_LENGTH, START_TOKEN, name="mediator", dropout_rate=M_DROPOUT_RATE, learning_rate=3e-3, with_professor_forcing=False) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.global_variables_initializer()) # First, use the oracle model to provide the positive examples, which are sampled from the oracle data distribution #generate_samples(sess, target_lstm, BATCH_SIZE, generated_num, positive_file) gen_data_loader.create_batches(oracle_file) #positive_file) gan_data_loader.create_batches(oracle_file) #positive_file) #generate_samples(sess, target_lstm, BATCH_SIZE, generated_num, eval_file) val_data_loader.create_batches(val_oracle_file) #eval_file) log = open('save/experiment-log.txt', 'w') log_nll = open('save/experiment-log-nll.txt', 'w') #log_jsd = open('save/experiment-log-jsd.txt', 'w') # pre-train generator (default 0 epochs)(not recommended) print('Start pre-training...') log.write('pre-training...\n') saver = tf.train.Saver(tf.global_variables()) if RESTORE: saver.restore(sess, "saved_model/CoT") for epoch in range(PRE_EPOCH_NUM): loss = mle_epoch(sess, generator, gen_data_loader) if epoch % 1 == 0: generate_samples(sess, generator, BATCH_SIZE, generated_num, negative_file) likelihood_data_loader.create_batches(negative_file) test_loss = target_loss(sess, target_lstm, likelihood_data_loader) print('pre-train epoch ', epoch, 'nll_oracle ', test_loss) buffer = 'epoch:\t' + str(epoch) + '\tnll_oracle:\t' + str( test_loss) + '\n' log_nll.write(buffer) if epoch % 1 == 0: test_loss = target_loss(sess, generator, val_data_loader) print('pre-train epoch ', epoch, 'nll_test ', test_loss) buffer = 'epoch:\t' + str(epoch) + '\tnll_test:\t' + str( test_loss) + '\n' log_nll.write(buffer) print( '#########################################################################' ) toc = time.time() # JJ print('Start Cooperative Training...') for iter_idx in range(TOTAL_BATCH): print('iteration: ' + str(iter_idx) + '\ntime: ' + str(time.time() - toc)) toc = time.time() # Train the generator for one step for it in range(1): samples = generator.generate(sess) rewards = mediator.get_reward(sess, samples) feed = {generator.x: samples, generator.rewards: rewards} _ = sess.run( generator.g_updates, feed_dict=feed ) # JJ -> loss, _ = sess.run([generator.g_loss, generator.g_updates], feed_dict=feed) # Test # JJ delete ''' if iter_idx % 100 == 0 or iter_idx == TOTAL_BATCH - 1: generate_samples(sess, generator, BATCH_SIZE, generated_num, negative_file) likelihood_data_loader.create_batches(negative_file) test_loss = target_loss(sess, target_lstm, likelihood_data_loader) buffer = 'batch:\t' + str(iter_idx) + '\tnll_oracle:\t' + str(test_loss) + '\n' print('batch: ', iter_idx, 'nll_oracle: ', test_loss) log_nll.write(buffer) ''' if iter_idx % gen_data_loader.num_batch == 0: # epochs instead of batches #if iter_idx % 100 == 0: test_loss = target_loss(sess, generator, val_data_loader) print('epoch:\t', iter_idx // gen_data_loader.num_batch, 'nll_test ', test_loss) buffer = 'epoch:\t' + str( iter_idx // gen_data_loader.num_batch) + '\tnll_test:\t' + str( test_loss) + '\n' #print('batch:\t', iter_idx, 'nll_test ', test_loss) #buffer = 'batch:\t'+ str(iter_idx) + '\tnll_test:\t' + str(test_loss) + '\n' log_nll.write(buffer) saver.save(sess, "saved_model/CoT") # Train the mediator for _ in range(1): bnll_ = [] """ d_loss_ = [] for it in range(3): feed = { mediator.x0: gan_data_loader.next_batch(), mediator.x1: generator.generate(sess) } d_loss, _ = sess.run([mediator.d_loss, mediator.d_update], feed) d_loss_.append(d_loss) """ for it in range(1): feed = { mediator.x0: gen_data_loader.next_batch(), mediator.x1: generator.generate(sess) } bnll = sess.run(mediator.likelihood_loss, feed) bnll_.append(bnll) sess.run(mediator.dropout_on) _ = sess.run(mediator.likelihood_updates, feed) sess.run(mediator.dropout_off) if iter_idx % 10 == 0: bnll = np.mean(bnll_) print("mediator cooptrain iter#%d, balanced_nll %f" % (iter_idx, bnll)) log.write("%d\t%f\n" % (iter_idx, bnll)) #if iter_idx % gen_data_loader.num_batch == 0: #jsd = jsd_calculate(sess, generator, target_lstm) #print('cooptrain epoch#', iter_idx // gen_data_loader.num_batch, 'jsd ', jsd) #log_jsd.write("%d\t%f\n" % (iter_idx // gen_data_loader.num_batch, jsd)) #saver.save(sess, "saved_model/CoT") log.close() log_nll.close()
def init_real_trainng(self, data_loc=None): from utils.text_process import text_precess, text_to_code from utils.text_process import get_tokenlized, get_word_list, get_dict if data_loc is None: data_loc = 'data/image_coco.txt' # 控制台直接运行函数输出(38, 4682) # end_token 4681 # start_token是0,seq中oracle文件是转码后的文本,里面没有start_token,但是运行的时候起始输入是0对应的向量 # 其实0对应的是个单词,并不是start_token,但是初始化统一为他也行 # return sequence_len+1, len(word_index_dict) + 1 self.sequence_length, self.vocab_size = text_precess(data_loc) end_token = self.vocab_size - 1 # self.sequence_length += 1 ###!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # goal_out_size = sum(self.num_filters) goal_out_size = self.emb_dim discriminator = Discriminator(sequence_length=self.sequence_length, num_classes=2, vocab_size=self.vocab_size, dis_emb_dim=self.dis_embedding_dim, filter_sizes=self.filter_size, num_filters=self.num_filters, batch_size=self.batch_size, hidden_dim=self.hidden_dim, start_token=self.start_token, goal_out_size=goal_out_size, step_size=self.step_size, l2_reg_lambda=self.l2_reg_lambda) # add self.set_discriminator(discriminator) # reward_co=self.reward_co att_model = Att_dis(vocab_size=self.vocab_size, emd_dim=self.emb_dim, sequence_length=self.sequence_length, batch_size=self.batch_size, sess=self.sess, end_token=end_token) self.att_model = att_model generator = Generator(num_classes=2, num_vocabulary=self.vocab_size, batch_size=self.batch_size, emb_dim=self.emb_dim, dis_emb_dim=self.dis_embedding_dim, goal_size=self.goal_size, hidden_dim=self.hidden_dim, sequence_length=self.sequence_length, filter_sizes=self.filter_size, start_token=self.start_token, num_filters=self.num_filters, goal_out_size=goal_out_size, D_model=discriminator, att_model=att_model, step_size=self.step_size, sess=self.sess, end_token=end_token) self.set_generator(generator) gen_dataloader = DataLoader(batch_size=self.batch_size, seq_length=self.sequence_length, end_token=end_token) oracle_dataloader = None dis_dataloader = DisDataloader(batch_size=self.batch_size, seq_length=self.sequence_length) self.set_data_loader(gen_loader=gen_dataloader, dis_loader=dis_dataloader, oracle_loader=oracle_dataloader) tokens = get_tokenlized(data_loc) word_set = get_word_list(tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(self.oracle_file, 'w') as outfile: outfile.write( text_to_code(tokens, word_index_dict, self.sequence_length)) return word_index_dict, index_word_dict
def main(): print('program start') from utils.text_process import text_precess, text_to_code # TODO: move? from utils.text_process import get_tokenlized, get_word_list, get_dict random.seed(SEED) np.random.seed(SEED) assert START_TOKEN == 0 SEQ_LENGTH, vocab_size = text_precess(true_file, val_file) gen_data_loader = Gen_Data_loader(BATCH_SIZE, SEQ_LENGTH) val_data_loader = Gen_Data_loader(BATCH_SIZE, SEQ_LENGTH) # Create training file and dicts tokens = get_tokenlized(true_file) val_tokens = get_tokenlized(val_file) word_set = get_word_list(tokens + val_tokens) [word_index_dict, index_word_dict] = get_dict(word_set) with open(oracle_file, 'w') as outfile: outfile.write(text_to_code(tokens, word_index_dict, SEQ_LENGTH)) with open(val_oracle_file, 'w') as outfile: outfile.write(text_to_code(val_tokens, word_index_dict, SEQ_LENGTH)) generator = Generator(vocab_size, BATCH_SIZE, EMB_DIM, HIDDEN_DIM, SEQ_LENGTH, START_TOKEN) #target_params = pickle.load(open('save/target_params_py3.pkl', 'rb')) #target_lstm = TARGET_LSTM(vocab_size, BATCH_SIZE, 32, 32, SEQ_LENGTH, START_TOKEN, target_params) # The oracle model # replace target lstm with true data mediator = Generator(vocab_size, BATCH_SIZE * 2, EMB_DIM * 2, HIDDEN_DIM * 2, SEQ_LENGTH, START_TOKEN, name="mediator", dropout_rate=M_DROPOUT_RATE) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(tf.global_variables_initializer()) gen_data_loader.create_batches(oracle_file) val_data_loader.create_batches(val_oracle_file) log = open('save/experiment-log.txt', 'w') log_nll = open('save/experiment-log-nll.txt', 'w') # pre-train generator (default 0 epochs)(not recommended) print('Start pre-training...') log.write('pre-training...\n') for epoch in range(PRE_EPOCH_NUM): loss = mle_epoch(sess, generator, gen_data_loader) if epoch % 5 == 0: generate_samples(sess, generator, BATCH_SIZE, generated_num, generator_file) #get_real_test_file(index_word_dict, generator_file, test_file) # only needed in debugging test_loss = target_loss(sess, generator, val_data_loader) print('pre-train epoch ', epoch, 'nll_test ', test_loss) buffer = 'epoch:\t' + str(epoch) + '\tnll_test:\t' + str( test_loss) + '\n' log_nll.write(buffer) print( '#########################################################################' ) toc = time.time() print('Start Cooperative Training...') for iter_idx in range(TOTAL_BATCH): print('iteration: ' + str(iter_idx) + '\ntime: ' + str(time.time() - toc)) toc = time.time() # Train the generator for one step for it in range(1): samples = generator.generate(sess) rewards = mediator.get_reward( sess, np.concatenate([samples, samples], axis=0)) feed = { generator.x: samples, generator.rewards: rewards[0:BATCH_SIZE] } loss, _ = sess.run([generator.g_loss, generator.g_updates], feed_dict=feed) # Test, removed oracle test if iter_idx % gen_data_loader.num_batch == 0: # epochs instead of batches test_loss = target_loss(sess, generator, val_data_loader) print('epoch:\t', iter_idx // gen_data_loader.num_batch, 'nll_test ', test_loss) buffer = 'epoch:\t' + str( iter_idx // gen_data_loader.num_batch) + '\tnll_test:\t' + str( test_loss) + '\n' log_nll.write(buffer) if iter_idx == TOTAL_BATCH - 1: print('generating samples') generate_samples(sess, generator, BATCH_SIZE, generated_num, generator_file) get_real_test_file(index_word_dict, generator_file, test_file) # Train the mediator for _ in range(1): print('training mediator...') bnll_ = [] collected_x = [] ratio = 2 for it in range(ratio): if it % 2 == 0: x_batch = gen_data_loader.next_batch() else: x_batch = generator.generate(sess) collected_x.append(x_batch) collected_x = np.reshape(collected_x, [-1, SEQ_LENGTH]) np.random.shuffle(collected_x) collected_x = np.reshape(collected_x, [-1, BATCH_SIZE * 2, SEQ_LENGTH]) for it in range(1): feed = { mediator.x: collected_x[it], } print('running bnll sess') bnll = sess.run(mediator.likelihood_loss, feed) bnll_.append(bnll) print('running mediator and updating') sess.run(mediator.dropout_on) _ = sess.run(mediator.likelihood_updates, feed) sess.run(mediator.dropout_off) if iter_idx % 50 == 0: bnll = np.mean(bnll_) print("mediator cooptrain iter#%d, balanced_nll %f" % (iter_idx, bnll)) log.write("%d\t%f\n" % (iter_idx, bnll)) log.close() log_nll.close()