def feed(self, iteration, report_dir, checkpoint_dir, datasets):
with tf.Session(
config=tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)) as sess:
last_iteration = session.current_epoch
training_losses = []
training_old_losses = []
testing_losses = []
testing_old_losses = []
for iter in range(iteration):
report_training = open(
os.path.join(report_dir, 'report_training.txt'), "a")
reporttrainingcsv = open(
os.path.join(report_dir, 'result_training.csv'), "a")
report_testing = open(
os.path.join(report_dir, 'report_testing.txt'), "a")
reporttestingcsv = open(
os.path.join(report_dir, 'result_testing.csv'), "a")
trainingcsvwriter = csv.writer(reporttrainingcsv)
testingcsvwriter = csv.writer(reporttestingcsv)
# =================================TRAINING PHASE=================================
print("iteration #" + str(iter + last_iteration))
report_training.write("iteration #" +
str(iter + last_iteration) + '\n')
csv_training_values = []
csv_training_values.append(iter + last_iteration)
if iter > 0:
training_old_losses = training_losses
training_losses = []
training_shuffled_index = np.arange(
len(datasets.training_dataset))
np.random.shuffle(training_shuffled_index)
for i in range(
int(
len(datasets.training_dataset) /
int(self.training_batch))):
session.start_timer()
csv_training_values = []
print(
"=================================TRAINING PHASE BATCH #"
+ str(i) + " ITERATION AT " + str(iter) +
"=================================")
report_training.write(
"=================================TRAINING PHASE BATCH #"
+ str(i) + " ITERATION AT " + str(iter) +
"=================================" + '\n')
csv_training_values.append(i)
csv_training_values.append(self.learning_rate)
# get batch shuffled index
batch_i = []
target = []
for j in range(self.training_batch):
batch_i.append(
datasets.training_dataset[training_shuffled_index[
j + (i * self.training_batch)]])
target.append(datasets.target_training_dataset[
training_shuffled_index[j +
(i *
self.training_batch)]])
batch_i = data_rep.sparse_dataset(batch_i)
print(batch_i.shape)
# batch_i = training_dataset[(i*batch):(i*batch)+batch]
sequence_length = np.array(
[batch_i.shape[1] for _ in range(self.training_batch)])
# target = target_training_dataset[(i*batch):(i*batch)+batch]
sparse_labels = data_rep.SimpleSparseTensorFrom(target)
feed = {
self.input_batch: batch_i,
self.seq_len: sequence_length,
self.targets: sparse_labels,
self.is_training: True,
self.alpha: self.learning_rate
}
loss, logg, _ = sess.run(
[self.avg_loss, self.decode, self.optimizer], feed)
print("Encoded CTC :")
report_training.write("Encoded CTC :" + '\n')
decode_text = data_rep.indices_to_text(logg[0][1])
print(decode_text)
print("first target : \n" +
data_rep.indices_to_text(target[0]))
report_training.write(decode_text + '\n')
report_training.write("first target : " +
data_rep.indices_to_text(target[0]) +
'\n')
csv_training_values.append(
data_rep.indices_to_text(target[0]))
#
# summ = sess.run(summaries, feed)
# writer.add_summary(summ,iter)
print("negative log-probability :" + str(loss))
report_training.write("negative log-probability :" +
str(loss) + '\n')
csv_training_values.append(loss)
csv_training_values.append(decode_text)
csv_training_values.append(
data_rep.indices_to_text(target[0]))
trainingcsvwriter.writerow(csv_training_values)
training_losses.append(loss)
session.stop_timer()
cycle_batch = int(
len(datasets.training_dataset) /
int(self.training_batch))
remaining_time = (((iteration - iter) * cycle_batch) -
i) * session.duration
report_training.write("Elapsed time: " +
str(session.duration) + '\n')
print("Remaining time : " + str(remaining_time))
report_training.write("Remaining time: " +
str(remaining_time) + '\n')
if iter > 0:
diff = np.array(training_losses) - np.array(
training_old_losses)
th = diff.mean()
percentage = th / np.array(
training_old_losses).mean() * 100
print("Learning performance : " + str(th))
report_training.write("Learning performance : " + str(th) +
'\n')
report_training.write("Learning percentage : " +
str(percentage) + '\n')
self.save(sess, checkpoint_dir, report_training)
"=================================TRAINING PHASE BATCH #" +
str(i) + " ITERATION AT " + str(iter) +
"=================================" + '\n')
csv_training_values.append(i)
csv_training_values.append(learning_rate)
# get batch shuffled index
batch_i = []
target = []
for j in range(training_batch):
batch_i.append(training_dataset[training_shuffled_index[
j + (i * training_batch)]])
target.append(target_training_dataset[
training_shuffled_index[j + (i * training_batch)]])
batch_i = data_rep.sparse_dataset(batch_i)
print(batch_i.shape)
# batch_i = training_dataset[(i*batch):(i*batch)+batch]
sequence_length = np.array(
[batch_i.shape[1] for _ in range(training_batch)])
# target = target_training_dataset[(i*batch):(i*batch)+batch]
sparse_labels = data_rep.SimpleSparseTensorFrom(target)
feed = {
input_batch: batch_i,
seq_len: sequence_length,
targets: sparse_labels,
is_training: True,
alpha: learning_rate
}
threshold = 0
testing_dataset = []
target_dataset = []
# load training dataset
for root, dirs, files in os.walk(training_dir, topdown=False):
for file in files:
if file[0] != '_':
print(os.path.join(training_dir, file))
target_dataset.append(
np.load(os.path.join(training_dir, '_' + file)))
new_testing_set = np.load(os.path.join(training_dir, file))
testing_dataset.append(new_testing_set)
testing_dataset = data_rep.sparse_dataset(testing_dataset)
with tf.device('/cpu:0'):
is_training = tf.placeholder(tf.bool, name="is_training")
# initialize input network
input_training = tf.placeholder(tf.float32, [None, None, None],
"input")
seq_len = tf.placeholder(tf.int32, [None], name="sequence_length")
with tf.name_scope('forward-net'):
# reshape to [batchsize * timestep x num_cepstrum]
training_batch = tf.reshape(input_training, [-1, num_cep])
with tf.variable_scope('fc1') as fc1:
w1 = tf.Variable(tf.random_normal([num_cep, n_hidden_1], mean,