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)
