def test(self):
#f = open('../demo/result.txt','w')
predict_result = []
with self.__session.as_default():
print('Testing')
for batch_y, batch_x in self.__data_manager.test_batches:
decoded = self.__session.run(self.__decoded,
feed_dict={
self.__inputs:
batch_x,
self.__seq_len:
[self.__max_char_count] *
self.__data_manager.batch_size
})
for i, y in enumerate(batch_y):
print('pic_name:')
print(batch_y[i])
name = ''.join(batch_y[i])
print('predict:')
print(ground_truth_to_word(decoded[i]))
ans = ''.join(ground_truth_to_word(decoded[i]))
str = name + ':' + ans + '\n'
#f.writelines(str)
predict_result.append(str)
#f.close()
tf.reset_default_graph()
return predict_result
def train(self, iteration_count):
self.step += 1
print("Step: ", self.step)
with self.__session.as_default():
train_writer = tf.summary.FileWriter('./logs',
self.__session.graph)
step_summary = self.step
print('Training')
for epoch in range(self.step, iteration_count + self.step):
iter_loss = 0
with open(self.__train_file, 'r') as file:
lines = [line.strip('\n') for line in file.readlines()]
random.shuffle(lines)
num_batch = len(lines) // self.__bs
for i in range(num_batch):
try:
batch_x, batch_y, batch_z = self.get_batch(
self.__bs, i, lines, self.__ex)
_, loss_value, probabilities, loss_sum, word_step_acc = self.__session.run(
[
self.__optimizer, self.__loss, self.__prob,
self.__loss_summary, self.__word_acc
],
feed_dict={
self.__inputs: batch_x,
self.__output: batch_y,
self.__length: batch_z
})
if i % int((num_batch / 3)) == 0:
for j in range(1):
print(ground_truth_to_word(batch_y[j]))
prob = np.argmax(probabilities[j], axis=-1)
print(ground_truth_to_word(prob))
print("loss: ", loss_value)
print("step: {}/{}".format(i, num_batch))
train_writer.add_summary(loss_sum, step_summary)
step_summary += 1
iter_loss += loss_value
except Exception as e:
print(str(e))
continue
self.__saver.save(self.__session,
self.__save_path,
global_step=epoch)
print('[{}] Iteration loss: {}'.format(epoch, iter_loss))
self.step += 1
return None
def train(self, iteration_count):
with self.__session.as_default():
print('Training')
for i in range(self.step, iteration_count + self.step):
iter_loss = 0
for batch_y, batch_dt, batch_x in self.__data_manager.train_batches:
op, decoded, loss_value = self.__session.run(
[self.__optimizer, self.__decoded, self.__cost],
feed_dict={
self.__inputs: batch_x,
self.__seq_len: [self.__max_char_count] * self.__data_manager.batch_size,
self.__targets: batch_dt
}
)
if i % 10 == 0:
for j in range(2):
print(batch_y[j])
print(ground_truth_to_word(decoded[j]))
iter_loss += loss_value
self.__saver.save(
self.__session,
self.__save_path,
global_step=self.step
)
print('[{}] Iteration loss: {}'.format(self.step, iter_loss))
self.step += 1
return None
def train(self, iteration_count):
with self.__session.as_default():
print('Training')
for i in range(self.step, iteration_count + self.step):
iter_loss = 0
for batch_y, batch_dt, batch_x in self.__data_manager.train_batches:
op, decoded, loss_value = self.__session.run(
[self.__optimizer, self.__decoded, self.__cost],
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size,
self.__targets:
batch_dt
})
if i % 10 == 0:
for j in range(2):
print(batch_y[j])
print(ground_truth_to_word(decoded[j]))
iter_loss += loss_value
self.__saver.save(self.__session,
self.__save_path,
global_step=self.step)
print('[{}] Iteration loss: {}'.format(self.step, iter_loss))
self.step += 1
return None
def train(self, iteration_count):
tensorboard_dir = 'tensorboard/dir'
merged = tf.summary.merge_all()
if not os.path.exists(tensorboard_dir):
os.makedirs(tensorboard_dir)
writer = tf.summary.FileWriter(tensorboard_dir)
dictionary, inverse_dictionary, dictionary_len = read_dictionary(
self.__data_manager.dictionary_path)
with self.__session.as_default():
print('Training')
for i in range(self.step, iteration_count + self.step):
iter_loss = 0
rs = 0
for batch_y, batch_dt, batch_x in self.__data_manager.train_batches:
op, loss_value, rs = self.__session.run(
[self.__optimizer, self.__cost, merged],
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size,
self.__targets:
batch_dt
})
if i % 50 == 0:
for j in range(2):
[decoded, acc] = self.__session.run(
[self.__decoded, self.__acc],
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size,
self.__targets:
batch_dt
})
print(batch_y[j])
print(acc)
print(
ground_truth_to_word(decoded[j],
inverse_dictionary))
iter_loss += loss_value
rs += rs
writer.add_summary(rs, i)
if i % 500 == 0:
self.__saver.save(self.__session,
self.__save_path,
global_step=self.step)
print('[{}] Iteration loss: {}'.format(self.step, iter_loss))
self.step += 1
writer.add_graph(self.__session.graph)
return None
def test(self):
with self.sess.as_default():
example_count = 0
total_error = 0
batch_x, batch_y, batch_length = self.data.get_next_test_batch(
self.batch_size)
data_targets = sparse_tuple_from(batch_y)
predict_str = self.sess.run([self.decoded],
feed_dict={
self.inputs: batch_x,
self.seq_len: batch_length
})
example_count += len(batch_y)
total_error += np.sum(
levenshtein(ground_truth_to_word(batch_y),
ground_truth_to_word(decoded)))
print "Error on test set: {}".format(total_error / example_count)
return None
def train(self, iteration_count, learning_rate_decay):
with self.__session.as_default():
print('Training')
for i in range(iteration_count):
iter_loss, len_loss, k = 0, 0, 0
if learning_rate_decay != 0 and i != 0 and i % learning_rate_decay == 0:
self.__start_learning_rate *= 0.1
pbar = tqdm(total=len(self.__data_manager.train_batches), ncols=150)
for batch_y, batch_dt, batch_x in self.__data_manager._generate_all_train_batches():
op, decoded, loss_value, acc, logits, out_len, cost_len = self.__session.run(
[self.__optimizer, self.__decoded, self.__cost, self.__acc, self.__logits, self.__output_len, self.__cost_len],
feed_dict={
self.__inputs: batch_x,
#self.__seq_len: [self.__max_char_count] * self.__data_manager.batch_size,
self.__targets: batch_dt,
self.__learning_rate: self.__start_learning_rate
}
)
#print('cost', out_len, cost_len)
if k > len(self.__data_manager.train_batches)-5:
for j in range(2):
print('GT:', batch_y[j])
print('PREDICT:', ground_truth_to_word(decoded[j], self.CHAR_VECTOR))
print(f'---- {i} ----')
sys.stdout.flush()
pbar.update(1)
k += 1
iter_loss += loss_value
len_loss += cost_len
pbar.set_postfix(
epoch=str(i)+'/'+str(iteration_count),
step=str(k),
cost="{:.2f}".format(iter_loss/float(k)),
cost_len="{:.2f}".format(len_loss/float(k)),
lr=str(self.__start_learning_rate)
)
self.__saver.save(
self.__session,
self.__save_path,
global_step=self.step
)
self.save_frozen_model("save/frozen.pb")
print('[{}] Iteration loss: {} Error rate: {}'.format(self.step, iter_loss, acc))
self.step += 1
return None
def train(self, iteration_count):
with self.session.as_default():
print("Training")
self.max_weight = tf.math.reduce_max(self.weight_matrix)
merged = tf.summary.merge_all()
for i in range(self.step, iteration_count + self.step):
print("Processing iteration ::", i)
batch_count = 0
iter_loss = 0
for batch_y, batch_dt, batch_x in self.data_manager.train_batches:
op, decoded, loss_value, acc, max_weight, summary = self.session.run(
[
self.optimizer, self.decoded, self.cost, self.acc,
self.max_weight, merged
],
feed_dict={
self.inputs:
batch_x,
self.seq_len: [self.max_char_count] *
self.data_manager.batch_size,
self.targets:
batch_dt,
},
)
self.train_summary_writer.add_summary(summary, self.step)
if i % 1 == 0:
for j in range(2):
print(f"decoded ...{decoded[0]}")
pred = ground_truth_to_word(
decoded[j], self.CHAR_VECTOR)
print("{} | {}".format(batch_y[j], pred))
print("---- {} | {} ----".format(i, batch_count))
iter_loss += loss_value
batch_count += 1
if batch_count >= 100:
break
self.saver.save(self.session,
self.save_path,
global_step=self.step)
self.train_summary_writer.flush()
self.save_frozen_model("save/frozen.pb")
print("[{}] Iteration loss: {} Error rate: {}".format(
self.step, iter_loss, acc))
print("max weight", max_weight)
self.step += 1
self.train_summary_writer.close()
return None
def test(self):
with self.__session.as_default():
print('Testing')
for batch_y, _, batch_x in self.__data_manager.test_batches:
output = self.__session.run(self.__output,
feed_dict={
self.__inputs: batch_x,
self.__is_training: False
})
for i, y in enumerate(batch_y):
print(batch_y[i])
print(ground_truth_to_word(output[i]))
def test(self):
with self.__session.as_default():
print('Testing')
total_error = 0
example_count = 0
for batch_y, batch_sl, batch_x in self.__data_manager.get_next_test_batch(
):
data_targets = np.asarray([
label_to_array(lbl, config.CHAR_VECTOR) for lbl in batch_y
])
data_targets = sparse_tuple_from(data_targets)
decoded = self.__session.run([self.__decoded],
feed_dict={
self.__inputs: batch_x,
self.__seq_len: batch_sl
})
example_count += len(batch_y)
total_error += np.sum(
levenshtein(ground_truth_to_word(batch_y),
ground_truth_to_word(decoded)))
print('Error on test set: {}'.format(total_error,
total_error / example_count))
return None
def train(self, iteration_count):
with self.__session.as_default():
print('Training')
for i in range(self.step, iteration_count + self.step):
iter_loss = 0
for batch_y, batch_seq_len, batch_dt, batch_dt_2, batch_x in self.__data_manager.train_batches:
_, output, loss_value, learning_rate, a1, a2, wm = self.__session.run(
[
self.__optimizer, self.__output, self.__loss,
self.__learning_rate, self.__a1, self.__a2,
self.__weight_mask
],
feed_dict={
self.__inputs: batch_x,
self.__seq_len: batch_seq_len,
self.__targets_1: batch_dt,
self.__targets_2: batch_dt_2,
self.__iteration_n:
[float(i) + 1.
], # +1 because 0^(0.5) is undefined obviously
self.__is_training: True
})
#print(batch_y[0])
#print(wm[0])
#input()
#
if i % 10 == 0:
for j in range(2):
print(batch_y[j])
print(batch_dt[j])
print(ground_truth_to_word(output[j]))
# print(output[0][0][0:15])
# print('------------')
# print(a2[0][0][0:15])
# print('------------')
# print(a2[1][0][0:15])
# input()
iter_loss += loss_value
self.__saver.save(self.__session,
self.__save_path,
global_step=self.step)
print('[{}] Iteration loss: {}'.format(self.step, iter_loss))
self.step += 1
return None
def test(self):
with self.__session.as_default():
print('Testing')
for batch_y, _, batch_x in self.__data_manager.test_batches:
decoded = self.__session.run(
self.__decoded,
feed_dict={
self.__inputs: batch_x,
self.__seq_len: [self.__max_char_count] * self.__data_manager.batch_size
}
)
for i, y in enumerate(batch_y):
print(batch_y[i])
print(ground_truth_to_word(decoded[i]))
return None
def test(self):
with self.__session.as_default():
print('Testing')
for batch_y, _, batch_x in self.__data_manager.test_batches:
decoded = self.__session.run(
self.__decoded,
feed_dict={
self.__inputs: batch_x,
#self.__seq_len: [self.__max_char_count] * self.__data_manager.batch_size
}
)
for i, y in enumerate(batch_y):
print(batch_y[i])
print(ground_truth_to_word(decoded[i], self.CHAR_VECTOR))
return None
def test(self, b_savePb=False, b_test=True, b_saveNG=True):
if b_saveNG:
# 创建空txt文档保存错误样本的路径
NG_path = self.__data_manager.examples_path + '_NG'
if not os.path.exists(NG_path):
os.mkdir(NG_path)
with self.__session.as_default():
if b_savePb:
self.save_PbModel()
if b_test:
count = 0
r = 0
for batch_y, _, batch_x in self.__data_manager.test_batches:
t1 = time.time()
decoded = self.__session.run(
self.__decoded,
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size
})
for i, y in enumerate(batch_y):
count += 1
label = self.__data_manager.get_label(batch_y[i])
predict = ground_truth_to_word(decoded[i])
if label == predict:
r += 1
else:
print(label)
print(predict)
if b_saveNG:
wrong_example = os.path.join(
self.__data_manager.examples_path,
batch_y[i])
object_path = os.path.join(NG_path, batch_y[i])
shutil.copyfile(wrong_example, object_path)
acc = r / count
print("Testing ,count:{},acc:{}".format(count, acc))
if b_saveNG:
print("错误样本保存到文件：{}".format(NG_path))
return None
def train(self, iteration_count):
with self.__session.as_default():
print("Training")
for i in range(self.step, iteration_count + self.step):
iter_loss = 0
for batch_y, batch_dt, batch_x in self.__data_manager.train_batches:
op, decoded, loss_value, acc = self.__session.run(
[
self.__optimizer, self.__decoded, self.__cost,
self.__acc
],
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size,
self.__targets:
batch_dt,
},
)
if i % 10 == 0:
for j in range(2):
print("GT:", batch_y[j])
print(
"PREDICT:",
ground_truth_to_word(decoded[j],
self.CHAR_VECTOR),
)
print(f"---- {i} ----")
iter_loss += loss_value
self.__saver.save(self.__session,
self.__save_path,
global_step=self.step)
self.save_frozen_model("save/frozen.pb")
print("[{}] Iteration loss: {} Error rate: {}".format(
self.step, iter_loss, acc))
self.step += 1
return None
def train(self, iteration_count):
with self.session.as_default():
print("Training")
for i in range(self.step, iteration_count + self.step):
batch_count = 0
iter_loss = 0
for batch_y, batch_dt, batch_x in self.data_manager.train_batches:
op, decoded, loss_value, acc = self.session.run(
[self.optimizer, self.decoded, self.cost, self.acc],
feed_dict={
self.inputs:
batch_x,
self.seq_len: [self.max_char_count] *
self.data_manager.batch_size,
self.targets:
batch_dt,
},
)
if i % 10 == 0:
for j in range(2):
pred = ground_truth_to_word(
decoded[j], self.CHAR_VECTOR)
print(f"{batch_y[j]} | {pred}")
print(f"---- {i} | {batch_count} ----")
iter_loss += loss_value
batch_count += 1
if batch_count >= 100:
break
self.saver.save(self.session,
self.save_path,
global_step=self.step)
self.save_frozen_model("save/frozen.pb")
print(
f"[{self.step}] Iteration loss: {iter_loss} Error rate: {acc}"
)
self.step += 1
return None
def test(self):
with self.session.as_default():
print("Testing")
for batch_y, _, batch_x in self.data_manager.test_batches:
decoded = self.session.run(
self.decoded,
feed_dict={
self.inputs:
batch_x,
self.seq_len:
[self.max_char_count] * self.data_manager.batch_size,
},
)
for i, y in enumerate(batch_y):
print("Ground truth", batch_y[i])
print(f"decode batch:{i}", decoded.shape)
print("Test result",
ground_truth_to_word(decoded[i], self.CHAR_VECTOR))
return None
def valid(self):
count = 0
r = 0
for batch_y, _, batch_x in self.__data_manager.test_batches:
t1 = time.time()
decoded = self.__session.run(
self.__decoded,
feed_dict={
self.__inputs:
batch_x,
self.__seq_len:
[self.__max_char_count] * self.__data_manager.batch_size
})
for i, y in enumerate(batch_y):
count += 1
label = self.__data_manager.get_label(batch_y[i])
predict = ground_truth_to_word(decoded[i])
if label == predict:
r += 1
acc = r / count
print("validation, count:{}, acc:{}".format(count, acc))
def train(self, iteration_count):
with self.__session.as_default():
print('Training')
for i in range(self.step, iteration_count + self.step):
iter_loss = 0
for batch_y, batch_sl, batch_x in self.__data_manager.get_next_train_batch(
):
data_targets = np.asarray([
label_to_array(lbl, config.CHAR_VECTOR)
for lbl in batch_y
])
data_targets = sparse_tuple_from(data_targets)
op, decoded, loss_value = self.__session.run(
[self.__optimizer, self.__decoded, self.__cost],
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size,
self.__targets:
data_targets
})
if i % 10 == 0:
for j in range(2):
print(batch_y[j])
print(ground_truth_to_word(decoded[j]))
iter_loss += loss_value
self.__saver.save(self.__session,
self.__save_path,
global_step=self.step)
print('[{}] Iteration loss: {}'.format(self.step, iter_loss))
self.step += 1
return None
def train(self, iteration_count):
with self.__session.as_default():
print('Training')
train_iteration_card_acc = []
train_iteration_num_acc = []
train_batch_card_acc = []
train_batch_num_acc = []
test_iteration_card_acc = []
test_iteration_num_acc = []
counts_train = 0
counts_test = 0
for i in range(self.step, iteration_count + self.step):
#iter_loss = 0
acc_card_train_ = 0
sum_card_train_ = 0
acc_num_train_ = 0
sum_num_train_ = 0
iter_loss_train = 0
acc_card_test_ = 0
sum_card_test_ = 0
acc_num_test_ = 0
sum_num_test_ = 0
iter_loss_test = 0
#train
#for k in range(1):
#batch_y,batch_dt,batch_x = self.__data_manager.train_batches[0]
for batch_y, batch_dt, batch_x in self.__data_manager.train_batches:
counts_train = counts_train + 1
acc_card_train = 0
sum_card_train = 0
acc_num_train = 0
sum_num_train = 0
#for batch_y, batch_dt, batch_x in self.__data_manager.train_batches:
op, decoded, loss_value, train_summary = self.__session.run(
[
self.__optimizer, self.__decoded, self.__cost,
self.__merged
],
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size,
self.__targets:
batch_dt
})
#print(decoded)
print(batch_y[0])
print(ground_truth_to_word(decoded[0]))
for j in range(self.__data_manager.batch_size):
true_label = batch_y[j]
predict_label = ground_truth_to_word(decoded[j])
#print(true_label)
#print(predict_label)
if true_label == predict_label:
acc_card_train = acc_card_train + 1
acc_num_train = acc_num_train + len(true_label)
sum_num_train = sum_num_train + len(true_label)
else:
sum_num_train = sum_num_train + len(true_label)
for i in range(
min(len(true_label), len(predict_label))):
if true_label[i] == predict_label[i]:
acc_num_train = acc_num_train + 1
sum_card_train = sum_card_train + 1
iter_loss_train += loss_value
acc_card_train_ += acc_card_train
sum_card_train_ += sum_card_train
acc_num_train_ += acc_num_train
sum_num_train_ += sum_num_train
train_batch_card_acc.append(acc_card_train /
sum_card_train)
train_batch_num_acc.append(acc_num_train / sum_num_train)
print('[{}] batch train_card_acc: {}'.format(
self.step, acc_card_train / sum_card_train))
print('[{}] batch train_number_acc: {}'.format(
self.step, acc_num_train / sum_num_train))
self.train_writer.add_summary(train_summary, counts_train)
train_iteration_card_acc.append(acc_card_train_ /
sum_card_train_)
train_iteration_num_acc.append(acc_num_train_ / sum_num_train_)
print('[{}] iteration train_loss: {}'.format(
self.step, iter_loss_train))
print('[{}] iteration train_card_acc: {}'.format(
self.step, acc_card_train_ / sum_card_train_))
print('[{}] iteration train_number_acc: {}'.format(
self.step, acc_num_train_ / sum_num_train_))
print('\n')
#test
for batch_y, batch_dt, batch_x in self.__data_manager.test_batches:
counts_test = counts_test + 1
acc_card_test = 0
sum_card_test = 0
acc_num_test = 0
sum_num_test = 0
#for batch_y, batch_dt, batch_x in self.__data_manager.train_batches:
decoded, loss_value, test_summary = self.__session.run(
[self.__decoded, self.__cost, self.__merged],
feed_dict={
self.__inputs:
batch_x,
self.__seq_len: [self.__max_char_count] *
self.__data_manager.batch_size,
self.__targets:
batch_dt
})
for j in range(self.__data_manager.batch_size):
true_label = batch_y[j]
predit_label = ground_truth_to_word(decoded[j])
#print(true_label)
#print(predit_label)
if true_label == predit_label:
acc_card_test = acc_card_test + 1
acc_num_test = acc_num_test + len(true_label)
sum_num_test = sum_num_test + len(true_label)
else:
sum_num_test = sum_num_test + len(true_label)
for i in range(
min(len(true_label), len(predict_label))):
if true_label[i] == predict_label[i]:
acc_num_test = acc_num_test + 1
sum_card_test = sum_card_test + 1
iter_loss_test += loss_value
acc_card_test_ += acc_card_test
sum_card_test_ += sum_card_test
acc_num_test_ += acc_num_test
sum_num_test_ += sum_num_test
self.test_writer.add_summary(test_summary, counts_test)
test_iteration_card_acc.append(acc_card_test_ / sum_card_test_)
test_iteration_num_acc.append(acc_num_test_ / sum_num_test_)
print('[{}] iteration test_loss: {}'.format(
self.step, iter_loss_test))
print('[{}] iteration test_card_acc: {}'.format(
self.step, acc_card_test_ / sum_card_test_))
print('[{}] iteration test_number_acc: {}'.format(
self.step, acc_num_test_ / sum_num_test_))
print('\n')
if self.step % 1 == 0:
self.__saver_whole.save(self.__session,
self.__save_path,
global_step=self.step)
self.step += 1
#iter_loss_tensor = tf.constant(iter_loss,tf.float32)
#test_acc_tensor = tf.constant(acc_num*1.0/sum_num,tf.float32)
#loss_sum = tf.summary.scalar("total_loss",iter_loss_tensor)
#acc_sum = tf.summary.scalar("test_acc",test_acc_tensor)
#merged = self.__session.run(tf.summary.merge_all())
np.savetxt("./train_batch_num_acc.txt", train_batch_num_acc)
np.savetxt("./train_batch_card_acc.txt", train_batch_card_acc)
np.savetxt("./train_iteration_num_acc.txt", train_iteration_num_acc)
np.savetxt("./train_iteration_card_acc.txt", train_iteration_card_acc)
np.savetxt("./test_iteration_num_acc.txt", test_iteration_num_acc)
np.savetxt("./test_iteration_card_acc.txt", test_iteration_card_acc)
self.train_writer.close()
self.test_writer.close()
return None
def train(self):
train_batches = utils.load_train_batches()
with self.__session.as_default():
print('Start train')
self.__train_writer.add_graph(self.__session.graph)
for i in range(self.step, config.EPOCHS):
# if self.__debug:
# print('trining step ' + str(i) + ':----------------------------------------------------')
iter_loss = 0
dists = []
learning_rates = []
batch_count = 0
batch_num = len(train_batches)
for batch_y, batch_dt, batch_x in train_batches:
batch_count += 1
start_time = time.time()
# if self.__debug:
# print('next batch:')
# print('batch_y.shape: ', batch_y.shape)
# print(batch_dt)
# print(batch_x.shape)
# options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
# run_metadata = tf.RunMetadata()
op, decoded, loss_value, dist, learning_rate = self.__session.run(
[
self.__optimizer, self.__decoded, self.__cost,
self.__dist, self.__learning_rate
],
feed_dict={
self.__inputs: batch_x,
self.__seq_len:
[self.__max_char_count] * self.__batch_size,
self.__targets: batch_dt,
self.__global_step: self.step
}
# options=options,
# run_metadata=run_metadata
)
if batch_count % config.REPORT_STEPS == 0:
elapsed = time.time() - start_time
print('training step [' + str(i) + '], batch ' +
str(batch_count) + '/' + str(batch_num) +
', elapsed: ' + str(elapsed) + ', loss_value: ' +
str(loss_value) + ', learning_rate: ' +
str(learning_rate))
# print real label and prediction label
# if i % config.REPORT_STEPS == 0 and batch_count%10 == 0:
if batch_count % config.REPORT_STEPS == 0:
for j in range(2):
print('batch_y[' + str(j) + ']:', batch_y[j])
print('ground_truth_to_word:',
utils.ground_truth_to_word(decoded[j]))
iter_loss += loss_value
dists.append(dist)
learning_rates.append(learning_rate)
# if self.__debug:
# #time line trace
# fetched_timeline = timeline.Timeline(run_metadata.step_stats)
# chrome_trace = fetched_timeline.generate_chrome_trace_format()
# with open('trace/timeline_batch_%d.json' % batch_count, 'w') as f:
# f.write(chrome_trace)
dist = np.mean(dists)
rate = np.mean(learning_rates)
summary = tf.Summary()
summary.value.add(tag="Edit Distance", simple_value=dist)
summary.value.add(tag="Learning Rate", simple_value=rate)
summary.value.add(tag="Loss", simple_value=iter_loss)
self.__train_writer.add_summary(summary=summary, global_step=i)
print('[{}] Iteration loss: {}, edit distance: {}----------'.
format(self.step, iter_loss, dist))
self.step += 1
self.__saver.save(self.__session,
self.__save_path,
global_step=self.step)
