def run_single_epoch(para, sess, model, train_data_generator):
logging.info("\n\nEpoch: %d" % epoch)
sess.run(train_data_generator.iterator.initializer)
start_time = time.time()
train_loss = 0.0
count = 0
while True:
try:
[
loss, global_step, _
] = sess.run(fetches=[model.loss, model.global_step, model.update])
train_loss += loss
count += 1
except tf.compat.v1.errors.OutOfRangeError:
logging.info("global step: %d, loss: %.5f, epoch time: %.3fs",
global_step, train_loss / count,
time.time() - start_time)
save_model(para, sess, model)
break
def pretrain(para, sess, model):
"""The procedure to pretrain the model"""
embed_dct = read_all_embedding()
step_time = 0.0
for step in range(1, para.steps + 1):
start_time = time.time()
[raw_rnn_inputs, raw_rnn_inputs_len, raw_target_outputs] = \
sess.run(
fetches=[
model.raw_rnn_inputs,
model.raw_rnn_inputs_len,
model.raw_target_outputs,
]
)
rnn_inputs_embedded = read_pretrained_embedding(
para, embed_dct, raw_rnn_inputs)
[loss, _] = sess.run(fetches=[
model.loss,
model.update,
],
feed_dict={
model.rnn_inputs_embedded:
rnn_inputs_embedded,
model.rnn_inputs_len: raw_rnn_inputs_len,
model.target_outputs: raw_target_outputs,
})
step_time += (time.time() - start_time)
if step % para.steps_per_stats == 0 or step == 1:
logging.info('step: %d, perplexity: %.2f, step_time: %.2f => save model to %s', \
step, np.exp(loss), step_time / para.steps_per_stats,
save_model_dir(para))
save_model(para, sess, model)
step_time = 0.0
if para.debug == 1:
exit()
def train(para, sess, model, train_data_generator):
valid_para, valid_graph, valid_model, valid_data_generator = \
create_valid_graph(para)
with tf.Session(config=config_setup(), graph=valid_graph) as valid_sess:
valid_sess.run(tf.global_variables_initializer())
for epoch in range(1, para.num_epochs + 1):
logging.info("Epoch: %d" % epoch)
sess.run(train_data_generator.iterator.initializer)
start_time = time.time()
train_loss = 0.0
count = 0
while True:
try:
[loss, global_step, _] = sess.run(
fetches=[model.loss, model.global_step, model.update])
train_loss += loss
count += 1
except tf.errors.OutOfRangeError:
logging.info(
"global step: %d, loss: %.5f, epoch time: %.3f",
global_step, train_loss / count,
time.time() - start_time)
save_model(para, sess, model)
break
# validation
load_weights(valid_para, valid_sess, valid_model)
valid_sess.run(valid_data_generator.iterator.initializer)
valid_loss = 0.0
valid_rse = 0.0
count = 0
n_samples = 0
all_outputs, all_labels = [], []
while True:
try:
[loss, outputs, labels] = valid_sess.run(fetches=[
valid_model.loss,
valid_model.all_rnn_outputs,
valid_model.labels,
])
if para.mts:
valid_rse += np.sum(
((outputs - labels) * valid_data_generator.scale)
**2)
all_outputs.append(outputs)
all_labels.append(labels)
n_samples += np.prod(outputs.shape)
valid_loss += loss
count += 1
except tf.errors.OutOfRangeError:
break
if para.mts:
all_outputs = np.concatenate(all_outputs)
all_labels = np.concatenate(all_labels)
sigma_outputs = all_outputs.std(axis=0)
sigma_labels = all_labels.std(axis=0)
mean_outputs = all_outputs.mean(axis=0)
mean_labels = all_labels.mean(axis=0)
idx = sigma_labels != 0
valid_corr = ((all_outputs - mean_outputs) *
(all_labels - mean_labels)).mean(
axis=0) / (sigma_outputs * sigma_labels)
valid_corr = valid_corr[idx].mean()
valid_rse = (
np.sqrt(valid_rse / n_samples) / train_data_generator.rse)
valid_loss /= count
logging.info(
"validation loss: %.5f, validation rse: %.5f, validation corr: %.5f",
valid_loss, valid_rse, valid_corr)
else:
logging.info("validation loss: %.5f", valid_loss / count)
def train(para, sess, model, train_data_generator):
valid_para, valid_graph, valid_model, valid_data_generator = \
create_valid_graph(para)
with tf.Session(config=config_setup(), graph=valid_graph) as valid_sess:
valid_sess.run(tf.global_variables_initializer())
for epoch in range(1, para.num_epochs + 1):
logging.info("\n\nEpoch: %d" % epoch)
sess.run(train_data_generator.iterator.initializer)
start_time = time.time()
train_loss = 0.0
count = 0
while True:
try:
[loss, global_step, _] = sess.run(
fetches=[model.loss, model.global_step, model.update])
train_loss += loss
count += 1
if count % 25 == 0:
# print(count, end=' ')
logging.debug(count)
except tf.compat.v1.errors.OutOfRangeError:
logging.info(
"global step: %d, loss: %.5f, epoch time: %.3fs",
global_step, train_loss / count,
time.time() - start_time)
#if para.save_models:
save_model(para, sess, model)
break
# validation
# if para.save_models:
load_weights(valid_para, valid_sess, valid_model)
# else:
# valid_model = model
valid_sess.run(valid_data_generator.iterator.initializer)
valid_loss = 0.0
valid_rse = 0.0
tp, fp, tn, fn = 0, 0, 0, 0
count = 0
n_samples = 0
all_outputs, all_labels = [], []
while True:
try:
[loss, outputs, labels] = valid_sess.run(fetches=[
valid_model.loss,
valid_model.all_rnn_outputs,
valid_model.labels,
])
if para.mts:
valid_rse += np.sum(((outputs - labels) *
valid_data_generator.scale)**2)
all_outputs.append(outputs)
all_labels.append(labels)
n_samples += np.prod(outputs.shape)
elif para.data_set == 'muse' or para.data_set == 'lpd5':
# print(np.shape(outputs))
# print(np.shape(labels))
# print(para.batch_size)
for b in range(
np.shape(outputs)[0]
): ##era para.batchsize, da' ultimul batch avea mai putine el
for p in range(128):
if outputs[b][p] >= 0.5 and labels[b][p] >= 0.5:
tp += 1
elif outputs[b][p] >= 0.5 and labels[b][
p] < 0.5:
fp += 1
elif outputs[b][p] < 0.5 and labels[b][p] < 0.5:
tn += 1
elif outputs[b][p] < 0.5 and labels[b][
p] >= 0.5:
fn += 1
# print([tp, fp, tn, fn])
valid_loss += loss
count += 1
except tf.errors.OutOfRangeError:
break
if para.mts:
all_outputs = np.concatenate(all_outputs)
all_labels = np.concatenate(all_labels)
sigma_outputs = all_outputs.std(axis=0)
sigma_labels = all_labels.std(axis=0)
mean_outputs = all_outputs.mean(axis=0)
mean_labels = all_labels.mean(axis=0)
idx = sigma_labels != 0
valid_corr = ((all_outputs - mean_outputs) *
(all_labels - mean_labels)).mean(
axis=0) / (sigma_outputs * sigma_labels)
valid_corr = valid_corr[idx].mean()
valid_rse = (np.sqrt(valid_rse / n_samples) /
train_data_generator.rse)
valid_loss /= count
logging.info(
"validation loss: %.5f, validation rse: %.5f, validation corr: %.5f",
valid_loss, valid_rse, valid_corr)
elif para.data_set == 'muse' or para.data_set == 'lpd5':
if (tp != 0 or fp != 0):
precision = tp / (tp + fp)
else:
precision = 0
recall = tp / (tp + fn)
if precision + recall >= 1e-6:
F1 = 2 * precision * recall / (precision + recall)
else:
F1 = 0.0
logging.info('validation loss: %.5f', valid_loss / count)
logging.info('precision: %.5f', precision)
logging.info('recall: %.5f', recall)
logging.info('F1 score: %.5f', F1)
def policy_gradient(para, sess, model): # pylint: disable=too-many-locals
"""The procedure of policy gradient reinforcement learning"""
embed_dct = read_all_embedding()
seed_id_list = read_all_seed_ids()
rev_vocab = read_rev_vocab()
original_para, original_graph, original_model = create_original_graph(para)
with tf.Session(config=config_setup(), graph=original_graph) as original_sess:
load_original_weights(original_para, original_sess, original_model)
step_time = 0.0
for step in range(1, para.steps + 1):
start_time = time.time()
chosen_ids = random.sample(range(0, len(seed_id_list)), para.batch_size)
seed_ids = [seed_id_list[idx] for idx in chosen_ids]
output_lengths = random.randint(1, para.max_len - 1)
# raw_rnn_inputs: [batch_size, output_lengths]
raw_rnn_inputs, _ = predict(rev_vocab, embed_dct, para, sess, model,
seed_ids, output_lengths, True)
# raw_rnn_inputs_len: [batch_size]
raw_rnn_inputs_len = np.array([output_lengths] * para.batch_size)
# raw_inputs_embedded: [batch_size, output_lengths, embedding_size]
rnn_inputs_embedded = read_pretrained_embedding(para, embed_dct, raw_rnn_inputs)
# get original probs
[probs] = original_sess.run(
fetches=[original_model.probs],
feed_dict={
original_model.rnn_inputs_embedded: rnn_inputs_embedded,
original_model.rnn_inputs_len: raw_rnn_inputs_len,
})
# get sampled ids
[sampled_ids] = sess.run(
fetches=[model.sampled_ids],
feed_dict={
model.rnn_inputs_embedded: rnn_inputs_embedded,
model.rnn_inputs_len: raw_rnn_inputs_len,
})
sampled_ids = np.reshape(sampled_ids, (para.batch_size))
# get reward
rewards, msg = reward_functions(para, raw_rnn_inputs, raw_rnn_inputs_len,
sampled_ids, probs)
[_] = sess.run(
fetches=[model.rl_update],
feed_dict={
model.rnn_inputs_embedded: rnn_inputs_embedded,
model.rnn_inputs_len: raw_rnn_inputs_len,
model.sampled_ids_inputs: sampled_ids,
model.rewards: rewards
})
step_time += (time.time() - start_time)
if step % para.steps_per_stats == 0 or step == 1:
logging.info('step: %d, reward: %.5f, step_time: %.2f => save model to %s',
step, msg['mean_reward'], step_time / para.steps_per_stats,
save_model_dir(para))
for key, value in msg.items():
if key == 'mean_reward':
continue
logging.info('%s: %.2f', key, value)
save_model(para, sess, model)
step_time = 0
if para.debug == 1:
exit()