def train(self, config): begin = time.clock() dataset = DataSet(config.train_datapath, config.batch_size) test_dataset = DataSet(config.train_datapath, config.batch_size, shuffle=False, onepass=True) # dataset = dataset # test_dataset = dataset create_conf = self.create_conf steps = dataset.steps * config.epoch print("total {} steps...".format(steps)) # sample_dirs = os.path.join("samples", self.model_name) # for dir in [sample_dirs, log_dirs]: # if os.path.exists(dir) == False: # os.makedirs(dir) # gpu_conf = tf.ConfigProto() # gpu_conf.gpu_options.per_process_gpu_memory_fraction = config.gpu_ratio with tf.Session() as session: log_dirs = os.path.join("./logs", self.model_name) if os.path.exists(log_dirs) == False: os.makedirs(log_dirs) load_model_dir = os.path.join('./backup', self.model_name) if config.load_checkpoint and os.path.exists(load_model_dir): self.load(session, load_model_dir) elif os.path.exists(load_model_dir): shutil.rmtree(load_model_dir) if config.load_checkpoint is False and os.path.exists(log_dirs): shutil.rmtree(log_dirs) os.makedirs(log_dirs) self.writer = tf.summary.FileWriter(log_dirs, session.graph) tf.global_variables_initializer().run() # sample_batch = dataset.sample_batch() # sample_mask = np.float32(sample_batch > 0.0) # sample_path = os.path.join(sample_dirs, "{}.sample".format(self.model_name)) # pd.DataFrame(sample_batch).to_csv(sample_path, index=False) for step in range(steps + 1): batch_data = dataset.next() mask = (batch_data == 0.0) # mask = np.float32(mask) if step % config.save_freq_steps != 0: _, loss, mse_loss, sparse_loss, rank_loss = session.run( [ self.apply_grads, self.loss, self.mse_loss, self.sparse_loss, self.rank_loss ], feed_dict={ self.X: batch_data, self.mask: mask, self.is_training: True, K.learning_phase(): 1 }) else: _, summary_str, loss, mse_loss, sparse_loss, rank_loss = session.run( [ self.apply_grads, self.merged_summary_op, self.loss, self.mse_loss, self.sparse_loss, self.rank_loss ], feed_dict={ self.X: batch_data, self.mask: mask, self.is_training: True, K.learning_phase(): 1 }) if step % config.log_freq_steps == 0: print( "step {}th, loss: {}, mse_loss: {}, sparse_loss: {}, rank_loss: {}" .format(step, loss, mse_loss, sparse_loss, rank_loss)) if step % config.save_freq_steps == 0: self.writer.add_summary(summary_str, step) # save_dir = os.path.join(config.checkpoint_dir, self.model_name) self.save(session, load_model_dir, step) self.predict_tmp(session, steps, test_dataset, config) end = time.clock() print("training {} cost time: {} mins".format(self.model_name, (end - begin) / 60.0))
def train(): LEARNING_RATE = 1e-3 BATCH_SIZE = 64 PRETRAIN_EPOCH = 1000 PRETRAIN_EPOCH_d = 1100 feature_nums = 15549 dropout_value = 0.9 dropout_sign = 1.0 train_datapath = r"F:/project/simulation_data/drop60_p.train" EPOCH = 2500 # outDir = r"F:/project/simulation_data/drop60/bn_" model_name = "AE-GAN_bn_dp_0.9_0_separate" load_checkpoint = False outDir = os.path.join("F:/project/simulation_data/drop60", model_name) model = "separate" x = tf.placeholder(tf.float32, [None, feature_nums], name="input_data") # completion = tf.placeholder(tf.float32, [BATCH_SIZE, feature_nums]) is_training = tf.placeholder(tf.bool, [], name="is_training") # completed = tf.placeholder(tf.float32,[None, feature_nums], name="generator_out") mask = tf.placeholder(tf.float32, [None, feature_nums], name="input_data") model = Simple_separate(x, mask, is_training, batch_size=BATCH_SIZE, feature_num=feature_nums, dropout_value=dropout_value, dropout_sign=dropout_sign, is_bn=True) sess = tf.Session() global_step = tf.Variable(0, name='global_step', trainable=False) epoch = tf.Variable(0, name='epoch', trainable=False) with tf.name_scope("adam_optimizer"): opt = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE) gv_train_op = opt.minimize(model.gv_loss, global_step=global_step, var_list=model.g_variables) g_train_op = opt.minimize(model.g_loss, global_step=global_step, var_list=model.g_variables) d_train_op = opt.minimize(model.d_loss, global_step=global_step, var_list=model.d_variables) init_op = tf.global_variables_initializer() sess.run(init_op) saver = tf.train.Saver() load_model_dir = os.path.join('./backup', model_name) if load_checkpoint and os.path.exists('./backup/' + model_name): ckpt = tf.train.get_checkpoint_state(load_model_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) elif os.path.exists(load_model_dir): shutil.rmtree(load_model_dir) else: os.makedirs(load_model_dir) logs_dir = os.path.join("./logs", model_name) if load_checkpoint is False and os.path.exists(logs_dir): shutil.rmtree(logs_dir) os.makedirs(logs_dir) writer = tf.summary.FileWriter(logs_dir, sess.graph) # if tf.train.get_checkpoint_state('./backup'): # saver = tf.train.Saver() # saver.restore(sess, './backup/latest') # # logs_dir = os.path.join("./logs", model_name) # if os.path.exists(logs_dir) == False: # os.makedirs(logs_dir) # writer = tf.summary.FileWriter(logs_dir, sess.graph) dataset = DataSet(train_datapath, BATCH_SIZE) # each epoch has step_num steps step_num = dataset.steps while sess.run(epoch) < EPOCH: sess.run(tf.assign(epoch, tf.add(epoch, 1))) print('epoch: {}'.format(sess.run(epoch))) # Completion if sess.run(epoch) <= PRETRAIN_EPOCH: for i in tqdm.tqdm(range(step_num)): x_batch = dataset.next() _, gv_loss, gv_summary_str = sess.run( [gv_train_op, model.gv_loss, model.gv_sum], feed_dict={ x: x_batch, is_training: True, K.learning_phase(): 1 }) if i % 10 == 0: writer.add_summary(gv_summary_str) print('Completion loss: {}'.format(gv_loss)) if sess.run(epoch) % 100 == 0: saver.save(sess, load_model_dir + '/pretrained_g', write_meta_graph=False) if sess.run(epoch) == PRETRAIN_EPOCH: dataset = DataSet(train_datapath, BATCH_SIZE, onepass=True, shuffle=False) imitate_datas = [] complete_datas = [] embed_datas = [] for i in tqdm.tqdm(range(step_num + 1)): x_batch = dataset.next() mask = x_batch == 0 embed, imitation, completion = sess.run( [ model.encoderv_out, model.imitation, model.completion ], feed_dict={ x: x_batch, is_training: False, K.learning_phase(): 0 }) completion = np.array(completion, dtype=np.float) imitation = np.array(imitation, dtype=np.float) embed = np.array(embed, dtype=np.float) mask = mask.astype(float) completion = x_batch * (1 - mask) + completion * mask imitation = x_batch * (1 - mask) + imitation * mask complete_datas.append(completion) imitate_datas.append(imitation) embed_datas.append(embed) dataset = DataSet(train_datapath, BATCH_SIZE) complete_datas = np.reshape( np.concatenate(complete_datas, axis=0), (-1, feature_nums)) imitate_datas = np.reshape( np.concatenate(imitate_datas, axis=0), (-1, feature_nums)) embed_datas = np.reshape(np.concatenate(embed_datas, axis=0), (-1, feature_nums // 32)) df_c = pd.DataFrame(complete_datas) df_i = pd.DataFrame(imitate_datas) df_e = pd.DataFrame(embed_datas) if os.path.exists(outDir) == False: os.makedirs(outDir) # outPath = os.path.join(outDir, "infer.complete") df_c.to_csv(outDir + "generator.imitate", index=None) df_i.to_csv(outDir + "generator.complete", index=None) df_e.to_csv(outDir + "generator.embed", index=None) print("save complete data to {}".format(outDir + "infer.complete")) saver.save(sess, load_model_dir + '/pretrained_g', write_meta_graph=False) # Discrimitation elif sess.run(epoch) <= PRETRAIN_EPOCH_d: for i in tqdm.tqdm(range(step_num)): x_batch = dataset.next() _, d_loss, d_summary_str = sess.run( [d_train_op, model.d_loss, model.d_sum], feed_dict={ x: x_batch, is_training: True, K.learning_phase(): 1 }) if i % 10 == 0: writer.add_summary(d_summary_str) print('Discriminator loss: {}'.format(d_loss)) if sess.run(epoch) % 100 == 0: saver = tf.train.Saver() saver.save(sess, load_model_dir + '/pretrained_d', write_meta_graph=False) # together elif sess.run(epoch) < EPOCH: for i in tqdm.tqdm(range(step_num)): x_batch = dataset.next() _, d_loss, d_summary_str = sess.run( [d_train_op, model.d_loss, model.d_sum], feed_dict={ x: x_batch, is_training: True, K.learning_phase(): 1 }) if i % 10 == 0: writer.add_summary(d_summary_str) _, g_loss, g_summary_str = sess.run( [g_train_op, model.g_loss, model.g_sum], feed_dict={ x: x_batch, is_training: True, K.learning_phase(): 1 }) if i % 10 == 0: writer.add_summary(g_summary_str) print('Completion loss: {}'.format(g_loss)) print('Discriminator loss: {}'.format(d_loss)) if sess.run(epoch) % 100 == 0: saver = tf.train.Saver() saver.save(sess, load_model_dir + '/latest', write_meta_graph=False) elif sess.run(epoch) == EPOCH: dataset = DataSet(train_datapath, BATCH_SIZE, onepass=True, shuffle=False) imitate_datas = [] complete_datas = [] embed_datas = [] for i in tqdm.tqdm(range(step_num + 1)): x_batch = dataset.next() mask = x_batch == 0 embed, imitation, completion = sess.run( [model.encoderv_out, model.imitation, model.completion], feed_dict={ x: x_batch, is_training: False, K.learning_phase(): 0 }) completion = np.array(completion, dtype=np.float) imitation = np.array(imitation, dtype=np.float) embed = np.array(embed, dtype=np.float) mask = mask.astype(float) completion = x_batch * (1 - mask) + completion * mask imitation = x_batch * (1 - mask) + imitation * mask complete_datas.append(completion) imitate_datas.append(imitation) embed_datas.append(embed) # saver = tf.train.Saver() # saver.save(sess, load_model_dir+'/complete', write_meta_graph=False) complete_datas = np.reshape(np.concatenate(complete_datas, axis=0), (-1, feature_nums)) imitate_datas = np.reshape(np.concatenate(imitate_datas, axis=0), (-1, feature_nums)) embed_datas = np.reshape(np.concatenate(embed_datas, axis=0), (-1, feature_nums // 32)) df_c = pd.DataFrame(complete_datas) df_i = pd.DataFrame(imitate_datas) df_e = pd.DataFrame(embed_datas) if os.path.exists(outDir) == False: os.makedirs(outDir) # outPath = os.path.join(outDir, "infer.complete") df_c.to_csv(outDir + "infer.imitate", index=None) df_i.to_csv(outDir + "infer.complete", index=None) df_e.to_csv(outDir + "infer.embed", index=None) print("save complete data to {}".format(outDir))
def predict(LEARNING_RATE1, LEARNING_RATE2, PRETRAIN_EPOCH, PRETRAIN_EPOCH_d, dropout_encoder, dropout_decoder, EPOCH, model_name, is_bn, is_log, is_mask, is_binary, is_dependent, is_after, is_before, is_bn_d, is_approximate, model="separate", load_checkpoint=False, train_datapath=r"F:/project/simulation_data/drop60_p.train", feature_nums=15549, dropout_sign=1.0): BATCH_SIZE = 64 outDir = os.path.join("F:/project/simulation_data/drop60", model_name) model = "separate" x = tf.placeholder(tf.float32, [None, feature_nums], name="input_data") # completion = tf.placeholder(tf.float32, [BATCH_SIZE, feature_nums]) is_training = tf.placeholder(tf.bool, [], name="is_training") # completed = tf.placeholder(tf.float32,[None, feature_nums], name="generator_out") learning_rate = tf.placeholder(tf.float32, shape=[]) model_dict = { "simple": Simple_model, "approximate": Softgum_app, "separate": Simple_separate } Network = model_dict[model] model = Network(x, is_training, batch_size=BATCH_SIZE, feature_num=feature_nums, dropout_value=dropout_value, dropout_sign=dropout_sign, is_bn=is_bn, is_log=is_log, is_mask=is_mask, is_binary=is_binary, is_dependent=is_dependent, is_after=is_after, is_before=is_before, is_approximate=is_approximate) sess = tf.Session() global_step = tf.Variable(0, name='global_step', trainable=False) epoch = tf.Variable(0, name='epoch', trainable=False) with tf.name_scope("adam_optimizer"): opt = tf.train.AdamOptimizer(learning_rate=learning_rate) gv_train_op = opt.minimize(model.gv_loss, global_step=global_step, var_list=model.g_variables) g_train_op = opt.minimize(model.g_loss, global_step=global_step, var_list=model.g_variables) d_train_op = opt.minimize(model.d_loss, global_step=global_step, var_list=model.d_variables) init_op = tf.global_variables_initializer() sess.run(init_op) saver = tf.train.Saver() load_model_dir = os.path.join('./backup', model_name) ckpt = tf.train.get_checkpoint_state(load_model_dir) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) #each epoch has step_num steps dataset = DataSet(train_datapath, BATCH_SIZE, onepass=True, shuffle=False) step_num = dataset.steps imitate_datas = [] complete_datas = [] embed_datas = [] for i in tqdm.tqdm(range(step_num + 1)): x_batch = dataset.next() mask = x_batch == 0 embed, imitation, completion = sess.run( [model.encoderv_out, model.imitation, model.completion], feed_dict={ x: x_batch, is_training: False, learning_rate: LEARNING_RATE2, K.learning_phase(): 0 }) completion = np.array(completion, dtype=np.float) imitation = np.array(imitation, dtype=np.float) embed = np.array(embed, dtype=np.float) mask = mask.astype(float) completion = x_batch * (1 - mask) + completion * mask imitation = x_batch * (1 - mask) + imitation * mask complete_datas.append(completion) imitate_datas.append(imitation) embed_datas.append(embed) complete_datas = np.reshape(np.concatenate(complete_datas, axis=0), (-1, feature_nums)) imitate_datas = np.reshape(np.concatenate(imitate_datas, axis=0), (-1, feature_nums)) embed_datas = np.reshape(np.concatenate(embed_datas, axis=0), (-1, feature_nums // 32)) df_c = pd.DataFrame(complete_datas) df_i = pd.DataFrame(imitate_datas) df_e = pd.DataFrame(embed_datas) if os.path.exists(outDir) == False: os.makedirs(outDir) # outPath = os.path.join(outDir, "infer.complete") df_c.to_csv(outDir + "infer.imitate", index=None) df_i.to_csv(outDir + "infer.complete", index=None) df_e.to_csv(outDir + "infer.embed", index=None) print("save complete data to {}".format(outDir))