def train(self): """ train """ gpu_options = tf.GPUOptions(allow_growth=True, per_process_gpu_memory_fraction=1.0) session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, gpu_options=gpu_options) with tf.Session(config=session_conf) as sess: sess.run(tf.global_variables_initializer()) current_step = 0 for epoch in range(self.config.epochs): start = time.time() print("-------- Epoch {}/{} -------".format( epoch + 1, self.config.epochs)) for batch in DataHelper.next_batch(self.train_data, self.config.batch_size): current_step += 1 loss = self.model.train(sess, batch, self.config) perplexity = cal_perplexity(loss) if current_step % 100 == 0: print("train ---> step: {}, loss: {}, perplexity: {}". format(current_step, loss, perplexity)) if current_step % self.config.eval_every == 0: eval_losses = [] eval_perplexities = [] for eval_batch in DataHelper.next_batch( self.eval_data, self.config.batch_size): eval_loss = self.model.eval(sess, eval_batch) eval_perplexity = cal_perplexity(eval_loss) eval_losses.append(eval_loss) eval_perplexities.append(eval_perplexity) print("\n") print("eval ---> step: {}, loss: {}, perplexity: {}". format(current_step, mean(eval_losses), mean(eval_perplexities))) print("\n") # 保存checkpoint model ckpt_model_path = self.config.ckpt_model_path if not os.path.exists(ckpt_model_path): os.makedirs(ckpt_model_path) ckpt_model_path = os.path.join(ckpt_model_path, "model") self.model.saver.save(sess, ckpt_model_path, global_step=current_step) end = time.time() print("------time: {}----------".format(end - start))
def train(self): """ train model :return: """ gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9, allow_growth=True) sess_config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True, gpu_options=gpu_options) with tf.Session(config=sess_config) as sess: # init all variable in graph sess.run(tf.global_variables_initializer()) current_step = 0 for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.train_data_obj.next_batch(self.train_data): loss, predictions = self.model.train(sess, batch, self.config["keep_prob"]) label_list = list(set(batch["labels"])) acc, recall, prec, f_beta = get_multi_metrics(pred_y=predictions, true_y=batch["labels"], labels=label_list) print("train: step: {}, loss: {}, acc: {}, recall: {}, precision: {}, f_beta: {}".format( current_step, loss, acc, recall, prec, f_beta)) current_step += 1 if current_step % self.config["checkpoint_every"] == 0: eval_losses = [] eval_accs = [] eval_recalls = [] eval_precs = [] eval_f_betas = [] for eval_batch in self.eval_data_obj.next_batch(self.eval_data): eval_loss, eval_predictions = self.model.eval(sess, eval_batch) eval_losses.append(eval_loss) eval_label_list = list(set(eval_batch["labels"])) acc, recall, prec, f_beta = get_multi_metrics(pred_y=eval_predictions, true_y=eval_batch["labels"], labels=eval_label_list) eval_accs.append(acc) eval_recalls.append(recall) eval_precs.append(prec) eval_f_betas.append(f_beta) print("\n") print("eval: loss: {}, acc: {}, recall: {}, precision: {}, f_beta: {}".format( mean(eval_losses), mean(eval_accs), mean(eval_recalls), mean(eval_precs), mean(eval_f_betas))) print("\n") if self.config["ckpt_model_path"]: save_path = os.path.join(os.path.abspath(os.getcwd()), self.config["ckpt_model_path"]) if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join(save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step)
def calculate_perturbation_factor(self, experiment, gene, pathway, visited=None): visited = [] if not visited else visited pf = 0 if len(set(gene.split(',')) & set(self.experiment_genes)) != 0: for name in gene.split(','): if name.strip() in self.experiment_genes: # get ΔE pf = self.FC['FC'][Gene(name)] if not isnan( self.FC['FC'][Gene(name)]) else MAX_IF break # genes directly upstream for edge in pathway.in_edges(gene): if edge[0] not in visited: beta = mean([ interaction_weights[t] if t in interaction_weights.keys() else 0 for t in get_edge_attributes(pathway, 'type')[edge] ]) # genes directly downstream dstream = len(pathway.out_edges(edge[0])) pf += self.calculate_perturbation_factor( experiment, edge[0], pathway, visited + [edge[1]]) * beta / dstream return pf
def calculate_impact_factor(self, experiment, pathway): path_genes = set( [x.strip() for x in ' ,'.join(pathway.nodes).split(',')]) DEGs_set = set([gene.name for gene in list(self.degs.index)]) # no DEGs in pathway if len(path_genes & DEGs_set) == 0: return None, None pval_path = hypergeom_distribution( len(path_genes & DEGs_set), len(self.experiment_genes), self.degs.size, len(path_genes & self.experiment_genes)) if pval_path != 0: impact_factor = log2(pval_path) impact_factor += sum([ abs( self.calculate_perturbation_factor( experiment, gene, pathway)) for gene in pathway.nodes ]) / len(path_genes & DEGs_set) * mean( [abs(i) for i in self.FC['FC'].values if not isnan(i)]) else: impact_factor = MAX_IF return impact_factor, pval_path
def train(self): with tf.Session() as sess: tvars = tf.trainable_variables() (assignment_map, initialized_variable_names) = modeling.get_assignment_map_from_checkpoint( tvars, self.__bert_checkpoint_path) print("init bert model params") tf.train.init_from_checkpoint(self.__bert_checkpoint_path, assignment_map) print("init bert model params done") sess.run(tf.variables_initializer(tf.global_variables())) current_step = 0 for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.data_obj.next_batch(self.t_in_ids_a, self.t_in_masks_a, self.t_seg_ids_a, self.t_in_ids_b, self.t_in_masks_b, self.t_seg_ids_b, self.t_lab_ids): loss, predictions = self.model.train(sess, batch) acc, recall, prec, f_beta = get_multi_metrics(pred_y=predictions, true_y=batch["label_ids"], labels=self.label_list) print("train: step: {}, loss: {}, acc: {}, recall: {}, precision: {}, f_beta: {}".format( current_step, loss, acc, recall, prec, f_beta)) current_step += 1 if self.data_obj and current_step % self.config["checkpoint_every"] == 0: eval_losses = [] eval_accs = [] eval_aucs = [] eval_recalls = [] eval_precs = [] eval_f_betas = [] for eval_batch in self.data_obj.next_batch(self.e_in_ids_a, self.e_in_masks_a, self.e_seg_ids_a, self.e_in_ids_b, self.e_in_masks_b, self.e_seg_ids_b, self.e_lab_ids): eval_loss, eval_predictions = self.model.eval(sess, eval_batch) eval_losses.append(eval_loss) acc, recall, prec, f_beta = get_multi_metrics(pred_y=eval_predictions, true_y=eval_batch["label_ids"], labels=self.label_list) eval_accs.append(acc) eval_recalls.append(recall) eval_precs.append(prec) eval_f_betas.append(f_beta) print("\n") print("eval: loss: {}, acc: {}, auc: {}, recall: {}, precision: {}, f_beta: {}".format( mean(eval_losses), mean(eval_accs), mean(eval_aucs), mean(eval_recalls), mean(eval_precs), mean(eval_f_betas))) print("\n") if self.config["ckpt_model_path"]: save_path = self.config["ckpt_model_path"] if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join(save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step)
def next(self): self.past_portfolio_values.append(self.portfolio.value) average_portfolio_value = Decimal(mean(self.past_portfolio_values)) smoothed_portfolio_value = average_portfolio_value * Decimal('1.1') withdrawal = self.withdrawal_rate * average_portfolio_value ceilinged = min(withdrawal, self.last_year * self.maximum_increase) floored = max(ceilinged, self.minimum * self.floor) self.last_year = floored if floored < self.minimum: self.minimum = floored return floored
def train(self): """ 训练模型 :return: """ gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9, allow_growth=True) sess_config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True, gpu_options=gpu_options) with tf.Session(config=sess_config) as sess: # 初始化变量值 sess.run(tf.global_variables_initializer()) current_step = 0 for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.data_obj.next_batch( self.train_queries, self.train_sims, self.train_labels, self.config["batch_size"]): loss, predictions = self.model.train( sess, batch, self.config["keep_prob"]) acc, rec, pre, f = get_binary_metrics( pred_y=predictions, true_y=batch["label"]) print( "train: step: {}, loss: {}, acc: {}, rec: {}, pre: {}, f: {}" .format(current_step, loss, acc, rec, pre, f)) current_step += 1 if current_step % self.config["checkpoint_every"] == 0: eval_losses = [] eval_acc = [] eval_rec = [] eval_pre = [] eval_f = [] for eval_batch in self.data_obj.next_batch( self.eval_queries, self.eval_sims, self.eval_labels, self.config["batch_size"]): eval_loss, eval_predictions = self.model.eval( sess, eval_batch) eval_losses.append(eval_loss) acc, rec, pre, f, = get_binary_metrics( pred_ys=eval_predictions, true_ys=eval_batch["labels"]) eval_acc.append(acc) eval_rec.append(rec) eval_pre.append(pre) eval_f.append(f) print("\n") print( "eval: , loss: {}, acc: {}, rec: {}, pre: {}, f: {}" .format(mean(eval_losses), mean(eval_acc), mean(eval_rec), mean(eval_pre), mean(eval_f))) print("\n") if self.config["ckpt_model_path"]: save_path = os.path.join( os.path.abspath(os.getcwd()), self.config["ckpt_model_path"]) if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join( save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step)
def train(self): with tf.Session() as sess: tvars = tf.trainable_variables() (assignment_map, initialized_variable_names ) = modeling.get_assignment_map_from_checkpoint( tvars, self.__bert_checkpoint_path) print("init bert model params") tf.train.init_from_checkpoint(self.__bert_checkpoint_path, assignment_map) print("init bert model params done") sess.run(tf.variables_initializer(tf.global_variables())) current_step = 0 start = time.time() for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.data_obj.next_batch(self.t_in_ids, self.t_in_masks, self.t_seg_ids, self.t_lab_ids, self.t_seq_len): loss, true_y, predictions = self.model.train( sess, batch, self.config["keep_prob"]) f1, precision, recall = gen_metrics( pred_y=predictions, true_y=true_y, label_to_index=self.lab_to_idx) print( "train: step: {}, loss: {}, recall: {}, precision: {}, f1: {}" .format(current_step, loss, recall, precision, f1)) current_step += 1 if self.data_obj and current_step % self.config[ "checkpoint_every"] == 0: eval_losses = [] eval_recalls = [] eval_precisions = [] eval_f1s = [] for eval_batch in self.data_obj.next_batch( self.e_in_ids, self.e_in_masks, self.e_seg_ids, self.e_lab_ids, self.e_seq_len): eval_loss, eval_true_y, eval_predictions = self.model.eval( sess, eval_batch) eval_losses.append(eval_loss) f1, precision, recall = gen_metrics( pred_y=eval_predictions, true_y=eval_true_y, label_to_index=self.lab_to_idx) eval_recalls.append(recall) eval_precisions.append(precision) eval_f1s.append(f1) print("\n") print( "eval: loss: {}, recall: {}, precision: {}, f1: {}" .format(mean(eval_losses), mean(eval_recalls), mean(eval_precisions), mean(eval_f1s))) print("\n") if self.config["ckpt_model_path"]: save_path = self.config["ckpt_model_path"] if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join( save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step) end = time.time() print("total train time: ", end - start)
def train(self): """ 训练模型 :return: """ with tf.device("cpu:0"), tf.Session() as sess: # 初始化变量值 sess.run(tf.global_variables_initializer()) current_step = 0 # 创建train和eval的summary路径和写入对象 train_summary_path = self.config["output_path"] + "/summary/train" if not os.path.exists(train_summary_path): os.makedirs(train_summary_path) train_summary_writer = tf.summary.FileWriter( train_summary_path, sess.graph) eval_summary_path = self.config["output_path"] + "/summary/eval" if not os.path.exists(eval_summary_path): os.makedirs(eval_summary_path) eval_summary_writer = tf.summary.FileWriter( eval_summary_path, sess.graph) state = np.zeros([ self.config["batch_size"] * 2 * self.config["num_layers"], self.config["hidden_size"] ]) for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.data_obj.next_batch( self.train_data, self.config["batch_size"], self.config["sequence_length"]): summary_op, loss, state = self.model.train( sess, batch, state, self.config["keep_prob"]) train_summary_writer.add_summary(summary_op) perplexity = math.exp( float(loss)) if loss < 300 else float("inf") print("train: step: {}, loss: {}, perplexity: {}".format( current_step, loss, perplexity)) current_step += 1 if current_step % self.config["eval_every"] == 0: eval_losses = [] eval_perplexities = [] eval_state = sess.run(self.model.initial_state) for eval_batch in self.data_obj.next_batch( self.eval_data, self.config["batch_size"], self.config["sequence_length"]): eval_summary_op, eval_loss, eval_state = self.model.eval( sess, eval_batch, eval_state) eval_summary_writer.add_summary(eval_summary_op) eval_perplexity = math.exp( float(eval_loss )) if eval_loss < 300 else float("inf") eval_losses.append(eval_loss) eval_perplexities.append(eval_perplexity) print("\n") print( "eval: step: {}, loss: {}, perplexity: {}".format( current_step, mean(eval_losses), mean(eval_perplexities))) print("\n") if self.config["ckpt_model_path"]: save_path = self.config["ckpt_model_path"] if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join(save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step) # 保存为pb文件 saved_model_path = self.config["pb_model_path"] if os.path.exists(saved_model_path): shutil.rmtree(saved_model_path) builder = tf.saved_model.builder.SavedModelBuilder( saved_model_path) inputs = { "inputs": tf.saved_model.utils.build_tensor_info(self.model.inputs), "initial_state": tf.saved_model.utils.build_tensor_info( self.model.initial_state), "keep_prob": tf.saved_model.utils.build_tensor_info(self.model.keep_prob) } outputs = { "predictions": tf.saved_model.utils.build_tensor_info(self.model.predictions), "final_state": tf.saved_model.utils.build_tensor_info(self.model.final_state) } prediction_signature = tf.saved_model.signature_def_utils.build_signature_def( inputs=inputs, outputs=outputs, method_name=tf.saved_model.signature_constants. PREDICT_METHOD_NAME) legacy_init_op = tf.group(tf.tables_initializer(), name="legacy_init_op") builder.add_meta_graph_and_variables( sess, [tf.saved_model.tag_constants.SERVING], signature_def_map={"language_model": prediction_signature}, legacy_init_op=legacy_init_op) builder.save()
f1 = cal_f1(batch["label"], binary_preds) current_step += 1 print("train: step: {}, loss: {}, acc: {}, auc: {}, f1: {}".format( current_step, loss, acc, auc, f1)) if current_step % FLAGS.steps_per_checkpoint == 0: eval_losses = [] eval_accs = [] eval_aucs = [] eval_f1s = [] for eval_batch in dataSet.next_batch(eval_data, FLAGS.batch_size): eval_loss, eval_preds, eval_binary_preds = model.eval( sess, eval_batch) eval_acc = cal_acc(eval_batch["label"], eval_binary_preds) eval_auc = cal_auc(eval_batch["label"], eval_preds) eval_f1 = cal_f1(eval_batch["label"], eval_binary_preds) eval_losses.append(eval_loss) eval_accs.append(eval_acc) eval_aucs.append(eval_auc) eval_f1s.append(eval_f1) print("\n") print("train: step: {}, loss: {}, acc: {}, auc: {}, f1: {}". format(current_step, mean(eval_losses), mean(eval_accs), mean(eval_aucs), mean(eval_f1s))) print("\n") checkpoint_path = os.path.join(FLAGS.model_dir, FLAGS.model_name) model.saver.save(sess, checkpoint_path, global_step=current_step)
def train(self): """ 训练模型 :return: """ with tf.Session() as sess: # 初始化变量值 sess.run(tf.global_variables_initializer()) current_step = 0 # 创建train和eval的summary路径和写入对象 train_summary_path = os.path.join( os.path.abspath(os.path.dirname(os.getcwd())), self.config["output_path"] + "/summary/train") if not os.path.exists(train_summary_path): os.makedirs(train_summary_path) train_summary_writer = tf.summary.FileWriter( train_summary_path, sess.graph) eval_summary_path = os.path.join( os.path.abspath(os.path.dirname(os.getcwd())), self.config["output_path"] + "/summary/eval") if not os.path.exists(eval_summary_path): os.makedirs(eval_summary_path) eval_summary_writer = tf.summary.FileWriter( eval_summary_path, sess.graph) for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.train_data_obj.next_batch( self.train_data, self.config["batch_size"]): # 是否在训练时选择计划采样 if self.config["schedule_sample"]: # sample_prob = self.schedule_sample(current_step, k=1300, mode="sigmoid") # sample_prob = self.schedule_sample(current_step) sample_prob = self.schedule_sample(current_step, mode="exponential") loss, predictions, summary = self.model.train( sess, batch, self.config["keep_prob"], sample_prob) else: loss, predictions, summary = self.model.train( sess, batch, self.config["keep_prob"]) # 将train参数加入到tensorboard中 train_summary_writer.add_summary(summary, current_step) perplexity = math.exp( float(loss)) if loss < 300 else float("inf") bleu = get_bleu(batch["responses"], predictions) print( "train: step: {}, loss: {}, perplexity: {}, bleu: {}". format(current_step, loss, perplexity, bleu)) current_step += 1 if self.eval_data and current_step % self.config[ "checkpoint_every"] == 0: eval_losses = [] eval_perplexities = [] eval_bleus = [] for eval_batch in self.eval_data_obj.next_batch( self.eval_data, self.config["batch_size"]): eval_loss, eval_predictions, eval_summary = self.model.eval( sess, eval_batch) # 将eval参数加入到tensorboard中 eval_summary_writer.add_summary( eval_summary, current_step) eval_perplexity = math.exp( float(eval_loss )) if eval_loss < 300 else float("inf") eval_bleu = get_bleu(eval_batch["responses"], eval_predictions) eval_losses.append(eval_loss) eval_perplexities.append(eval_perplexity) eval_bleus.append(eval_bleu) print("\n") print( "eval: step: {}, loss: {}, perplexity: {}, bleu: {}" .format(current_step, mean(eval_losses), mean(eval_perplexities), mean(eval_bleus))) print("\n") if self.config["ckpt_model_path"]: save_path = os.path.join( os.path.abspath(os.path.dirname(os.getcwd())), self.config["ckpt_model_path"]) if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join( save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step)
def train(self): """ train model :return: """ current_step = 0 loss_function = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(self.model.parameters(), lr=self.config["learning_rate"]) for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.train_data_obj.next_batch(self.train_tasks): predictions = self.model(batch) # print(predictions) optimizer.zero_grad() labels = torch.LongTensor(batch["labels"]) # labels = self.one_hot(labels) # print(labels) loss = loss_function(predictions, labels) loss.backward() optimizer.step() # print(predictions) label_list = list(set(batch["labels"])) predictions_max = torch.argmax(predictions, dim=1) acc, recall, prec, f_beta = get_multi_metrics( pred_y=predictions_max, true_y=batch["labels"], labels=label_list) current_step += 1 print( "train: step: {}, loss: {}, acc: {}, recall: {}, precision: {}, f_beta: {}" .format(current_step, loss, acc, recall, prec, f_beta)) if current_step % self.config["checkpoint_every"] == 0: eval_losses = [] eval_accs = [] eval_recalls = [] eval_precs = [] eval_f_betas = [] for eval_batch in self.train_data_obj.next_batch( self.eval_tasks): eval_predictions = self.model(eval_batch) eval_labels = torch.LongTensor(eval_batch["labels"]) eval_loss = loss_function(eval_predictions, eval_labels) eval_losses.append(eval_loss) eval_label_list = list(set(eval_batch["labels"])) eval_predictions_max = torch.argmax(eval_predictions, dim=1) acc, recall, prec, f_beta = get_multi_metrics( pred_y=eval_predictions_max, true_y=eval_batch["labels"], labels=eval_label_list) eval_accs.append(acc) eval_recalls.append(recall) eval_precs.append(prec) eval_f_betas.append(f_beta) print("\n") print( "eval: loss: {}, acc: {}, recall: {}, precision: {}, f_beta: {}" .format(mean(eval_losses), mean(eval_accs), mean(eval_recalls), mean(eval_precs), mean(eval_f_betas))) print("\n")
def train(self): with tf.Session() as sess: tvars = tf.trainable_variables() (assignment_map, initialized_variable_names ) = modeling.get_assignment_map_from_checkpoint( tvars, self.__bert_checkpoint_path) print("init bert model params") tf.train.init_from_checkpoint(self.__bert_checkpoint_path, assignment_map) print("init bert model params done") sess.run(tf.variables_initializer(tf.global_variables())) current_step = 0 for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) t_in_ids_a, t_in_masks_a, t_seg_ids_a, t_in_ids_b, t_in_masks_b, t_seg_ids_b = \ self.data_obj.gen_task_samples(self.queries, self.config["train_n_tasks"]) for batch in self.data_obj.next_batch(t_in_ids_a, t_in_masks_a, t_seg_ids_a, t_in_ids_b, t_in_masks_b, t_seg_ids_b): loss, predictions = self.model.train(sess, batch) acc = accuracy(predictions) print("train: step: {}, loss: {}, acc: {}".format( current_step, loss, acc)) current_step += 1 if self.data_obj and current_step % self.config[ "checkpoint_every"] == 0: e_in_ids_a, e_in_masks_a, e_seg_ids_a, e_in_ids_b, e_in_masks_b, e_seg_ids_b = \ self.data_obj.gen_task_samples(self.queries, self.config["eval_n_tasks"]) eval_losses = [] eval_accs = [] for eval_batch in self.data_obj.next_batch( e_in_ids_a, e_in_masks_a, e_seg_ids_a, e_in_ids_b, e_in_masks_b, e_seg_ids_b): eval_loss, eval_predictions = self.model.eval( sess, eval_batch) eval_losses.append(eval_loss) acc = accuracy(eval_predictions) eval_accs.append(acc) print("\n") print("eval: loss: {}, acc: {}".format( mean(eval_losses), mean(eval_accs))) print("\n") if self.config["ckpt_model_path"]: save_path = self.config["ckpt_model_path"] if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join( save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step)
def next(self): amount = self.strategy.next() self.lookback.append(amount) return Decimal(mean(self.lookback))
def train(self): """ 训练模型 :return: """ gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9, allow_growth=True) sess_config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True, gpu_options=gpu_options) with tf.Session(config=sess_config) as sess: # 初始化变量值 sess.run(tf.global_variables_initializer()) current_step = 0 # 创建train和eval的summary路径和写入对象 train_summary_path = os.path.join( os.path.abspath(os.path.dirname(os.getcwd())), self.config["output_path"] + "/summary/train") if not os.path.exists(train_summary_path): os.makedirs(train_summary_path) train_summary_writer = tf.summary.FileWriter( train_summary_path, sess.graph) eval_summary_path = os.path.join( os.path.abspath(os.path.dirname(os.getcwd())), self.config["output_path"] + "/summary/eval") if not os.path.exists(eval_summary_path): os.makedirs(eval_summary_path) eval_summary_writer = tf.summary.FileWriter( eval_summary_path, sess.graph) for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.train_data_obj.next_batch( self.train_inputs, self.train_labels, self.config["batch_size"]): summary, loss, predictions = self.model.train( sess, batch, self.config["keep_prob"]) # 将train参数加入到tensorboard中 train_summary_writer.add_summary(summary, current_step) hamming_loss, macro_f1, macro_prec, macro_rec, micro_f1, micro_prec, micro_rec = get_metrics( y=batch["y"], y_pre=predictions) print( "train: step: {}, loss: {}, hamming_loss: {}, macro_f1: {}, macro_prec: {}, macro_rec: {}, " "micro_f1: {}, micro_prec: {}, micro_rec: {}".format( current_step, loss, hamming_loss, macro_f1, macro_prec, macro_rec, micro_f1, micro_prec, micro_rec)) current_step += 1 if self.eval_data_obj and current_step % self.config[ "checkpoint_every"] == 0: eval_losses = [] eval_hamming_losses = [] eval_macro_f1s = [] eval_macro_recs = [] eval_macro_precs = [] eval_micro_f1s = [] eval_micro_precs = [] eval_micro_recs = [] for eval_batch in self.eval_data_obj.next_batch( self.eval_inputs, self.eval_labels, self.config["batch_size"]): eval_summary, eval_loss, eval_predictions = self.model.eval( sess, eval_batch) # 将eval参数加入到tensorboard中 eval_summary_writer.add_summary( eval_summary, current_step) eval_losses.append(eval_loss) hamming_loss, macro_f1, macro_prec, macro_rec, micro_f1, micro_prec, micro_rec = \ get_metrics(y=eval_batch["y"], y_pre=eval_predictions) eval_losses.append(eval_loss) eval_hamming_losses.append(hamming_loss) eval_macro_f1s.append(macro_f1) eval_macro_precs.append(macro_prec) eval_macro_recs.append(macro_f1) eval_micro_f1s.append(micro_f1) eval_micro_precs.append(micro_prec) eval_micro_recs.append(micro_rec) print("\n") print( "eval: step: {}, loss: {}, hamming_loss: {}, macro_f1: {}, macro_prec: {}, macro_rec: {}, " "micro_f1: {}, micro_prec: {}, micro_rec: {}". format(current_step, mean(eval_losses), mean(eval_hamming_losses), mean(eval_macro_f1s), mean(eval_macro_precs), mean(eval_macro_recs), mean(eval_micro_f1s), mean(eval_micro_precs), mean(eval_micro_recs))) print("\n") if self.config["ckpt_model_path"]: save_path = os.path.join( os.path.abspath(os.path.dirname(os.getcwd())), self.config["ckpt_model_path"]) if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join( save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step)
def train(self): """ 训练模型 :return: """ with tf.Session() as sess: # 初始化变量值 sess.run(tf.global_variables_initializer()) current_step = 0 # 创建train和eval的summary路径和写入对象 train_summary_path = self.config["output_path"] + "/summary/train" if not os.path.exists(train_summary_path): os.makedirs(train_summary_path) train_summary_writer = tf.summary.FileWriter(train_summary_path, sess.graph) eval_summary_path = self.config["output_path"] + "/summary/eval" if not os.path.exists(eval_summary_path): os.makedirs(eval_summary_path) eval_summary_writer = tf.summary.FileWriter(eval_summary_path, sess.graph) state = sess.run(self.model.initial_state) for epoch in range(self.config["epochs"]): print("----- Epoch {}/{} -----".format(epoch + 1, self.config["epochs"])) for batch in self.data_obj.next_batch(self.train_data, self.config["batch_size"], self.config["sequence_length"]): summary_op, loss, state = self.model.train(sess, batch, state, self.config["keep_prob"]) train_summary_writer.add_summary(summary_op) perplexity = math.exp(float(loss)) if loss < 300 else float("inf") print("train: step: {}, loss: {}, perplexity: {}".format(current_step, loss, perplexity)) current_step += 1 if current_step % self.config["checkpoint_every"] == 0: eval_losses = [] eval_perplexities = [] eval_state = sess.run(self.model.initial_state) for eval_batch in self.data_obj.next_batch(self.eval_data, self.config["batch_size"], self.config["sequence_length"]): eval_summary_op, eval_loss, eval_state = self.model.eval(sess, eval_batch, eval_state) eval_summary_writer.add_summary(eval_summary_op) eval_perplexity = math.exp(float(eval_loss)) if eval_loss < 300 else float("inf") eval_losses.append(eval_loss) eval_perplexities.append(eval_perplexity) print("\n") print("eval: step: {}, loss: {}, perplexity: {}".format(current_step, mean(eval_losses), mean(eval_perplexities))) print("\n") if self.config["ckpt_model_path"]: save_path = self.config["ckpt_model_path"] if not os.path.exists(save_path): os.makedirs(save_path) model_save_path = os.path.join(save_path, self.config["model_name"]) self.model.saver.save(sess, model_save_path, global_step=current_step)
recalls = [] for batchEval in nextBatch(evalReviews, evalLabels, config.batchSize): loss, acc, precision, recall, f_beta = devStep( batchEval[0], batchEval[1]) losses.append(loss) accs.append(acc) f_betas.append(f_beta) precisions.append(precision) recalls.append(recall) time_str = datetime.datetime.now().isoformat() print( "{}, step: {}, loss: {}, acc: {},precision: {}, recall: {}, f_beta: {}" .format(time_str, currentStep, mean(losses), mean(accs), mean(precisions), mean(recalls), mean(f_betas))) if currentStep % config.training.checkpointEvery == 0: # 保存模型的另一种方法,保存checkpoint文件 path = saver.save(sess, "../model/Transformer/model/my-model", global_step=currentStep) print("Saved model checkpoint to {}\n".format(path)) inputs = { "inputX": tf.saved_model.utils.build_tensor_info(transformer.inputX), "keepProb": tf.saved_model.utils.build_tensor_info(transformer.dropoutKeepProb)