def run_epoch(self,
session,
features,
labels,
batch_size,
epoch,
use_tensorboard,
tensorboard_writer,
feed_dict=None,
train_flag=True):
loss_ep = 0
ler_ep = 0
n_step = 0
database = list(zip(features, labels))
for batch in self.create_batch(database, batch_size):
batch_features, batch_labels = zip(*batch)
# Padding input to max_time_step of this batch
batch_train_features, batch_train_seq_len = padSequences(
batch_features)
batch_train_labels, batch_train_labels_len = padSequences(
batch_labels, dtype=np.int64, value=LASLabel.UNK_INDEX)
input_feed_dict = {
self.input_features: batch_train_features,
self.input_features_length: batch_train_seq_len,
self.input_labels: batch_train_labels,
self.input_labels_length: batch_train_labels_len
}
if feed_dict is not None:
input_feed_dict = {**input_feed_dict, **feed_dict}
if use_tensorboard:
s = session.run(self.merged_summary, feed_dict=input_feed_dict)
tensorboard_writer.add_summary(s, epoch)
use_tensorboard = False # Only on one batch
if train_flag:
loss, _, ler = session.run(
[self.loss, self.train_op, self.ler],
feed_dict=input_feed_dict)
else:
loss, ler = session.run([self.loss, self.ler],
feed_dict=input_feed_dict)
loss_ep += loss
ler_ep += ler
n_step += 1
return loss_ep / n_step, ler_ep / n_step
def validate(self,
input_seq,
output_seq,
show_partial: bool = True,
batch_size: int = 1):
with self.graph.as_default():
sess = tf.Session(graph=self.graph)
sess.run(tf.global_variables_initializer())
self.load_checkpoint(sess)
acum_err = 0
acum_loss = 0
n_step = 0
database = list(zip(input_seq, output_seq))
batch_list = self.create_batch(database, batch_size)
for batch in batch_list:
in_seq, out_seq = zip(*batch)
# Padding input to max_time_step of this batch
batch_in_seq, batch_seq_len = padSequences(in_seq)
batch_out_seq, _ = padSequences(out_seq)
feed_dict = {
self.input_feature: batch_in_seq,
# self.seq_len: batch_seq_len,
self.output_feature: batch_out_seq,
self.tf_is_traing_pl: False
}
error, loss = sess.run([self.reconstruction_loss, self.loss],
feed_dict=feed_dict)
if show_partial:
print("Batch %d of %d, error %f" %
(n_step + 1, len(batch_list), error))
acum_err += error
acum_loss += loss
n_step += 1
print("Validation error: %f, loss: %f" %
(acum_err / n_step, acum_loss / n_step))
sess.close()
return acum_err / len(input_seq), acum_loss / len(input_seq)
def predict(self, feature):
feature = np.reshape(feature, [1, len(feature), np.shape(feature)[1]])
with tf.Session(graph=self.graph) as sess:
sess.run(tf.global_variables_initializer())
self.load_checkpoint(sess)
features, seq_len = padSequences(feature)
feed_dict = {
self.input_features: features,
self.input_features_length: seq_len,
self.tf_is_traing_pl: False
}
predicted = sess.run(self.decoded_ids, feed_dict=feed_dict)
sess.close()
return predicted[0]
def validate(self,
features,
labels,
show_partial: bool = True,
batch_size: int = 1):
with self.graph.as_default():
sess = tf.Session(graph=self.graph)
sess.run(tf.global_variables_initializer())
self.load_checkpoint(sess)
acum_ler = 0
acum_loss = 0
n_step = 0
database = list(zip(features, labels))
batch_list = self.create_batch(database, batch_size)
for batch in batch_list:
feature, label = zip(*batch)
# Padding input to max_time_step of this batch
batch_features, batch_seq_len = padSequences(feature)
# Converting to sparse representation so as to to feed SparseTensor input
batch_labels = sparseTupleFrom(label)
feed_dict = {
self.input_feature: batch_features,
self.seq_len: batch_seq_len,
self.input_label: batch_labels,
self.tf_is_traing_pl: False
}
ler, loss = sess.run([self.ler, self.logits_loss],
feed_dict=feed_dict)
if show_partial:
print("Batch %d of %d, ler %f" %
(n_step + 1, len(batch_list), ler))
acum_ler += ler
acum_loss += loss
n_step += 1
print("Validation ler: %f, loss: %f" %
(acum_ler / n_step, acum_loss / n_step))
sess.close()
return acum_ler / len(labels), acum_loss / len(labels)
def encode(self, feature):
with tf.Session(graph=self.graph) as sess:
sess.run(tf.global_variables_initializer())
self.load_checkpoint(sess)
# Padding input to max_time_step of this batch
features, seq_len = padSequences([feature])
feed_dict = {
self.input_seq: features,
self.seq_len: seq_len,
self.tf_is_traing_pl: False
}
encoding = sess.run(self.encoder_out, feed_dict=feed_dict)
sess.close()
return encoding[0]
def predict(self, feature):
feature = np.reshape(feature, [1, len(feature), np.shape(feature)[1]])
with tf.Session(graph=self.graph) as sess:
sess.run(tf.global_variables_initializer())
self.load_checkpoint(sess)
# Padding input to max_time_step of this batch
features, seq_len = padSequences(feature)
feed_dict = {
self.input_feature: features,
self.seq_len: seq_len,
self.tf_is_traing_pl: False
}
predicted = sess.run(self.decoded, feed_dict=feed_dict)
sess.close()
return self.decoderOutputToText(predicted)
def run_epoch(self, session, features, labels, batch_size, epoch,
use_tensorboard, tensorboard_writer, feed_dict=None, train_flag=True):
loss_ep = 0
ler_ep = 0
n_step = 0
database = list(zip(features, labels))
for batch in self.create_batch(database, batch_size):
batch_features, batch_labels = zip(*batch)
# Padding input to max_time_step of this batch
batch_train_features, batch_train_seq_len = padSequences(batch_features)
# Converting to sparse representation so as to feed SparseTensor input
batch_train_labels = sparseTupleFrom(batch_labels)
input_feed_dict = {
self.input_features: batch_train_features,
self.input_features_length: batch_train_seq_len,
self.input_labels: batch_train_labels
}
if feed_dict is not None:
input_feed_dict = {**input_feed_dict, **feed_dict}
if use_tensorboard:
s = session.run(self.merged_summary, feed_dict=input_feed_dict)
tensorboard_writer.add_summary(s, epoch)
use_tensorboard = False # Only on one batch
if train_flag:
loss, _, ler = session.run([self.loss, self.train_op, self.ler], feed_dict=input_feed_dict)
else:
loss, ler = session.run([self.loss, self.ler], feed_dict=input_feed_dict)
loss_ep += loss
ler_ep += ler
n_step += 1
return loss_ep / n_step, ler_ep / n_step
def train(self,
train_features,
train_labels,
batch_size: int,
training_epochs: int,
restore_run: bool = True,
save_partial: bool = True,
save_freq: int = 10,
shuffle: bool = True,
use_tensorboard: bool = False,
tensorboard_freq: int = 50):
with self.graph.as_default():
sess = tf.Session(graph=self.graph)
sess.run(tf.global_variables_initializer())
if restore_run:
self.load_checkpoint(sess)
train_writer = None
if use_tensorboard:
train_writer = self.create_tensorboard_writer(
self.network_data.tensorboard_path + '/train', self.graph)
train_writer.add_graph(sess.graph)
loss_ep = 0
ler_ep = 0
for epoch in range(training_epochs):
epoch_time = time.time()
loss_ep = 0
ler_ep = 0
n_step = 0
database = list(zip(train_features, train_labels))
for batch in self.create_batch(database, batch_size):
batch_features, batch_labels = zip(*batch)
# Padding input to max_time_step of this batch
batch_train_features, batch_train_seq_len = padSequences(
batch_features)
# Converting to sparse representation so as to feed SparseTensor input
batch_train_labels = sparseTupleFrom(batch_labels)
feed_dict = {
self.input_feature: batch_train_features,
self.seq_len: batch_train_seq_len,
self.input_label: batch_train_labels
}
loss, _, ler = sess.run(
[self.loss, self.training_op, self.ler],
feed_dict=feed_dict)
loss_ep += loss
ler_ep += ler
n_step += 1
loss_ep = loss_ep / n_step
ler_ep = ler_ep / n_step
if use_tensorboard:
if epoch % tensorboard_freq == 0 and self.network_data.tensorboard_path is not None:
random_index = random.randint(0,
len(train_features) - 1)
feature = [train_features[random_index]]
label = [train_labels[random_index]]
# Padding input to max_time_step of this batch
tensorboard_features, tensorboard_seq_len = padSequences(
feature)
# Converting to sparse representation so as to to feed SparseTensor input
tensorboard_labels = sparseTupleFrom(label)
tensorboard_feed_dict = {
self.input_feature: tensorboard_features,
self.seq_len: tensorboard_seq_len,
self.input_label: tensorboard_labels
}
s = sess.run(self.merged_summary,
feed_dict=tensorboard_feed_dict)
train_writer.add_summary(s, epoch)
if save_partial:
if epoch % save_freq == 0:
self.save_checkpoint(sess)
self.save_model(sess)
if shuffle:
aux_list = list(zip(train_features, train_labels))
random.shuffle(aux_list)
train_features, train_labels = zip(*aux_list)
print(
"Epoch %d of %d, loss %f, ler %f, epoch time %.2fmin, ramaining time %.2fmin"
% (epoch + 1, training_epochs, loss_ep, ler_ep,
(time.time() - epoch_time) / 60,
(training_epochs - epoch - 1) *
(time.time() - epoch_time) / 60))
# save result
self.save_checkpoint(sess)
self.save_model(sess)
sess.close()
return ler_ep, loss_ep
def train(self,
input_seq,
output_seq,
batch_size: int,
training_epochs: int,
restore_run: bool = True,
save_partial: bool = True,
save_freq: int = 10,
shuffle: bool = True,
use_tensorboard: bool = False,
tensorboard_freq: int = 50):
with self.graph.as_default():
sess = tf.Session(graph=self.graph)
sess.run(tf.global_variables_initializer())
if restore_run:
self.load_checkpoint(sess)
train_writer = None
if use_tensorboard:
if self.network_data.tensorboard_path is not None:
# Set up tensorboard summaries and saver
if tf.gfile.Exists(self.network_data.tensorboard_path +
'/train') is not True:
tf.gfile.MkDir(self.network_data.tensorboard_path +
'/train')
else:
tf.gfile.DeleteRecursively(
self.network_data.tensorboard_path + '/train')
train_writer = tf.summary.FileWriter(
"{}train".format(self.network_data.tensorboard_path),
self.graph)
train_writer.add_graph(sess.graph)
loss_ep = 0
for epoch in range(training_epochs):
epoch_time = time.time()
loss_ep = 0
n_step = 0
database = list(zip(input_seq, output_seq))
for batch in self.create_batch(database, batch_size):
batch_in_seq, batch_out_seq = zip(*batch)
# Padding input to max_time_step of this batch
batch_train_in_seq, batch_train_seq_len = padSequences(
batch_in_seq)
batch_train_out_seq, _ = padSequences(batch_out_seq)
feed_dict = {
self.input_seq: batch_train_in_seq,
self.seq_len: batch_train_seq_len,
self.output_seq: batch_train_in_seq
}
loss, _ = sess.run([self.loss, self.optimizer],
feed_dict=feed_dict)
loss_ep += loss
n_step += 1
loss_ep = loss_ep / n_step
if use_tensorboard:
if epoch % tensorboard_freq == 0 and self.network_data.tensorboard_path is not None:
random_index = random.randint(0, len(input_seq) - 1)
in_seq = [input_seq[random_index]]
out_seq = [output_seq[random_index]]
# Padding input to max_time_step of this batch
tensorboard_in_seq, tensorboard_seq_len = padSequences(
in_seq)
tensorboard_out_seq, _ = padSequences(out_seq)
tensorboard_feed_dict = {
self.input_seq: tensorboard_in_seq,
self.seq_len: tensorboard_seq_len,
self.output_seq: tensorboard_out_seq
}
s = sess.run(self.merged_summary,
feed_dict=tensorboard_feed_dict)
train_writer.add_summary(s, epoch)
if save_partial:
if epoch % save_freq == 0:
self.save_checkpoint(sess)
self.save_model(sess)
if shuffle:
aux_list = list(zip(input_seq, output_seq))
random.shuffle(aux_list)
input_seq, output_seq = zip(*aux_list)
print(
"Epoch %d of %d, loss %f, epoch time %.2fmin, ramaining time %.2fmin"
% (epoch + 1, training_epochs, loss_ep,
(time.time() - epoch_time) / 60,
(training_epochs - epoch - 1) *
(time.time() - epoch_time) / 60))
# save result
self.save_checkpoint(sess)
self.save_model(sess)
sess.close()
return loss_ep