update: eval1, eval2

LICENSE

@@ -0,0 +1,19 @@
+The MIT License (MIT) Copyright (c) 2016 Igor Babuschkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

convert.py

@@ -17,51 +17,32 @@
 from tensorpack.predict.config import PredictConfig
 from tensorpack.tfutils.sessinit import SaverRestore
 from tensorpack.tfutils.sessinit import ChainInit
-
-
-def convert(model, mfccs, spec, mel, ckpt1=None, ckpt2=None):
-    session_inits = []
-    if ckpt2:
-        session_inits.append(SaverRestore(ckpt2))
-    if ckpt1:
-        session_inits.append(SaverRestore(ckpt1, ignore=['global_step']))
-
-    pred_conf = PredictConfig(
-        model=model,
-        input_names=get_eval_input_names(),
-        output_names=get_eval_output_names(),
-        session_init=ChainInit(session_inits))
-    predict_spec = OfflinePredictor(pred_conf)
-
-    pred_spec, y_spec, ppgs = predict_spec(mfccs, spec, mel)
-
-    return pred_spec, y_spec, ppgs
-
-
-def get_eval_input_names():
-    return ['x_mfccs', 'y_spec', 'y_mel']
-
-
-def get_eval_output_names():
-    return ['pred_spec', 'y_spec', 'net1/ppgs']
-
-
-def do_convert(args, logdir1, logdir2):
-
-    # Load graph
-    model = Net2(batch_size=hp.convert.batch_size)
-
-    df = Net2DataFlow(hp.convert.data_path, hp.convert.batch_size)
-
-    # samples
-    mfccs, spec, mel = df().get_data().next()
-
-    ckpt1 = tf.train.latest_checkpoint(logdir1)
-    ckpt2 = '{}/{}'.format(logdir2, args.ckpt) if args.ckpt else tf.train.latest_checkpoint(logdir2)
-
-    pred_spec, y_spec, ppgs = convert(model, mfccs, spec, mel, ckpt1, ckpt2)
-    print(np.max(pred_spec))
-    print(np.min(pred_spec))
+from tensorpack.callbacks.base import Callback
+
+
+# class ConvertCallback(Callback):
+#     def __init__(self, logdir, test_per_epoch=1):
+#         self.df = Net2DataFlow(hp.convert.data_path, hp.convert.batch_size)
+#         self.logdir = logdir
+#         self.test_per_epoch = test_per_epoch
+#
+#     def _setup_graph(self):
+#         self.predictor = self.trainer.get_predictor(
+#             get_eval_input_names(),
+#             get_eval_output_names())
+#
+#     def _trigger_epoch(self):
+#         if self.epoch_num % self.test_per_epoch == 0:
+#             audio, y_audio, _ = convert(self.predictor, self.df)
+#             # self.trainer.monitors.put_scalar('eval/accuracy', acc)
+#
+#             # Write the result
+#             # tf.summary.audio('A', y_audio, hp.default.sr, max_outputs=hp.convert.batch_size)
+#             # tf.summary.audio('B', audio, hp.default.sr, max_outputs=hp.convert.batch_size)
+
+
+def convert(predictor, df):
+    pred_spec, y_spec, ppgs = predictor(next(df().get_data()))
 
     # Denormalizatoin
     pred_spec = denormalize_db(pred_spec, hp.default.max_db, hp.default.min_db)
@@ -85,10 +66,43 @@ def do_convert(args, logdir1, logdir2):
     audio = inv_preemphasis(audio, coeff=hp.default.preemphasis)
     y_audio = inv_preemphasis(y_audio, coeff=hp.default.preemphasis)
 
-    if hp.convert.one_full_wav:
-        # Concatenate to a wav
-        y_audio = np.reshape(y_audio, (1, y_audio.size), order='C')
-        audio = np.reshape(audio, (1, audio.size), order='C')
+    # if hp.convert.one_full_wav:
+    #     # Concatenate to a wav
+    #     y_audio = np.reshape(y_audio, (1, y_audio.size), order='C')
+    #     audio = np.reshape(audio, (1, audio.size), order='C')
+
+    return audio, y_audio, ppgs
+
+
+def get_eval_input_names():
+    return ['x_mfccs', 'y_spec', 'y_mel']
+
+
+def get_eval_output_names():
+    return ['pred_spec', 'y_spec', 'ppgs']
+
+
+def do_convert(args, logdir1, logdir2):
+    # Load graph
+    model = Net2()
+
+    df = Net2DataFlow(hp.convert.data_path, hp.convert.batch_size)
+
+    ckpt1 = tf.train.latest_checkpoint(logdir1)
+    ckpt2 = '{}/{}'.format(logdir2, args.ckpt) if args.ckpt else tf.train.latest_checkpoint(logdir2)
+    session_inits = []
+    if ckpt2:
+        session_inits.append(SaverRestore(ckpt2))
+    if ckpt1:
+        session_inits.append(SaverRestore(ckpt1, ignore=['global_step']))
+    pred_conf = PredictConfig(
+        model=model,
+        input_names=get_eval_input_names(),
+        output_names=get_eval_output_names(),
+        session_init=ChainInit(session_inits))
+    predictor = OfflinePredictor(pred_conf)
+
+    audio, y_audio, ppgs = convert(predictor, df)
 
     # Write the result
     tf.summary.audio('A', y_audio, hp.default.sr, max_outputs=hp.convert.batch_size)
@@ -137,4 +151,4 @@ def get_arguments():
 
     e = datetime.datetime.now()
     diff = e - s
-    print("Done. elapsed time:{}s".format(diff.seconds))
+    print("Done. elapsed time:{}s".format(diff.seconds))

data_load.py

@@ -22,8 +22,7 @@ def __init__(self, data_path, batch_size):
 
     def __call__(self, n_prefetch=1000, n_thread=1):
         df = self
-        if self.batch_size > 1:
-            df = BatchData(df, self.batch_size)
+        df = BatchData(df, self.batch_size)
         df = PrefetchData(df, n_prefetch, n_thread)
         return df
 

eval1.py

@@ -7,65 +7,54 @@
 
 import tensorflow as tf
 
-from data_load import get_batch, phns, load_vocab
+from data_load import Net1DataFlow, phns, load_vocab
 from hparam import hparam as hp
-from models import Model
+from models import Net1
 from utils import plot_confusion_matrix
+from tensorpack.predict.config import PredictConfig
+from tensorpack.predict.base import OfflinePredictor
+from tensorpack.tfutils.sessinit import SaverRestore
 
 
-def eval(logdir, writer, queue=False):
-    # Load graph
-    model = Model(mode="test1", batch_size=hp.test1.batch_size, queue=queue)
-
-    # Accuracy
-    acc_op = model.acc_net1()
+def get_eval_input_names():
+    return ['x_mfccs', 'y_ppgs']
 
-    # Loss
-    loss_op = model.loss_net1()
 
-    # confusion matrix
-    y_ppg_1d = tf.reshape(model.y_ppg, shape=(tf.size(model.y_ppg),))
-    pred_ppg_1d = tf.reshape(model.pred_ppg, shape=(tf.size(model.pred_ppg),))
+def get_eval_output_names():
+    return ['net1/eval/y_ppg_1d', 'net1/eval/pred_ppg_1d',  'net1/eval/summ_loss', 'net1/eval/summ_acc']
 
-    # Summary
-    tf.summary.scalar('net1/eval/acc', acc_op)
-    tf.summary.scalar('net1/eval/loss', loss_op)
-    summ_op = tf.summary.merge_all()
 
-    session_conf = tf.ConfigProto(
-        allow_soft_placement=True,
-        device_count={'CPU': 1, 'GPU': 0},
-    )
-    with tf.Session(config=session_conf) as sess:
-        coord = tf.train.Coordinator()
-        threads = tf.train.start_queue_runners(coord=coord)
+def eval(logdir):
+    # Load graph
+    model = Net1()
 
-        # Load trained model
-        sess.run(tf.global_variables_initializer())
-        model.load(sess, 'train1', logdir=logdir)
+    # dataflow
+    df = Net1DataFlow(hp.test1.data_path, hp.test1.batch_size)
 
-        if queue:
-            summ, acc, loss, y_ppg_1d, pred_ppg_1d = sess.run([summ_op, acc_op, loss_op, y_ppg_1d, pred_ppg_1d])
-        else:
-            mfcc, ppg = get_batch(model.mode, model.batch_size)
-            summ, acc, loss, y_ppg_1d, pred_ppg_1d = sess.run([summ_op, acc_op, loss_op, y_ppg_1d, pred_ppg_1d],
-                                                              feed_dict={model.x_mfcc: mfcc, model.y_ppg: ppg})
+    ckpt = tf.train.latest_checkpoint(logdir)
 
-        # plot confusion matrix
-        _, idx2phn = load_vocab()
-        y_ppg_1d = [idx2phn[i] for i in y_ppg_1d]
-        pred_ppg_1d = [idx2phn[i] for i in pred_ppg_1d]
-        cm_summ = plot_confusion_matrix(y_ppg_1d, pred_ppg_1d, phns)
+    pred_conf = PredictConfig(
+        model=model,
+        input_names=get_eval_input_names(),
+        output_names=get_eval_output_names())
+    if ckpt:
+        pred_conf.session_init = SaverRestore(ckpt)
+    predictor = OfflinePredictor(pred_conf)
 
-        writer.add_summary(summ)
-        writer.add_summary(cm_summ)
+    x_mfccs, y_ppgs = next(df().get_data())
+    y_ppg_1d, pred_ppg_1d, summ_loss, summ_acc = predictor(x_mfccs, y_ppgs)
 
-        print("acc:", acc)
-        print("loss:", loss)
-        print('\n')
+    # plot confusion matrix
+    _, idx2phn = load_vocab()
+    y_ppg_1d = [idx2phn[i] for i in y_ppg_1d]
+    pred_ppg_1d = [idx2phn[i] for i in pred_ppg_1d]
+    summ_cm = plot_confusion_matrix(y_ppg_1d, pred_ppg_1d, phns)
 
-        coord.request_stop()
-        coord.join(threads)
+    writer = tf.summary.FileWriter(logdir)
+    writer.add_summary(summ_loss)
+    writer.add_summary(summ_acc)
+    writer.add_summary(summ_cm)
+    writer.close()
 
 
 def get_arguments():
@@ -79,8 +68,6 @@ def get_arguments():
     args = get_arguments()
     hp.set_hparam_yaml(args.case)
     logdir = '{}/train1'.format(hp.logdir)
-    writer = tf.summary.FileWriter(logdir)
-    eval(logdir=logdir, writer=writer)
-    writer.close()
+    eval(logdir=logdir)
 
-    print("Done")
+    print("Done")

eval2.py

@@ -4,68 +4,67 @@
 from __future__ import print_function
 
 import tensorflow as tf
-from data_load import get_batch
-from models import Model
+from models import Net2
 import argparse
 from hparam import hparam as hp
+from tensorpack.predict.base import OfflinePredictor
+from tensorpack.predict.config import PredictConfig
+from tensorpack.tfutils.sessinit import SaverRestore
+from tensorpack.tfutils.sessinit import ChainInit
+from data_load import Net2DataFlow
 
 
-def eval(logdir, writer, queue=True):
+def get_eval_input_names():
+    return ['x_mfccs', 'y_spec']
 
-    # Load graph
-    model = Model(mode="test2", batch_size=hp.test2.batch_size, queue=queue)
-
-    # Loss
-    loss_op = model.loss_net2()
-
-    # Summary
-    summ_op = summaries(loss_op)
-
-    session_conf = tf.ConfigProto(
-        allow_soft_placement=True,
-        device_count={'CPU': 1, 'GPU': 0},
-    )
-    with tf.Session(config=session_conf) as sess:
-        # Load trained model
-        sess.run(tf.global_variables_initializer())
-        model.load(sess, 'test2', logdir=logdir)
-
-        coord = tf.train.Coordinator()
-        threads = tf.train.start_queue_runners(coord=coord)
-
-        if queue:
-            summ, loss = sess.run([summ_op, loss_op])
-        else:
-            mfcc, spec, mel = get_batch(model.mode, model.batch_size)
-            summ, loss = sess.run([summ_op, loss_op], feed_dict={model.x_mfcc: mfcc, model.y_spec: spec, model.y_mel: mel})
 
-        writer.add_summary(summ)
+def get_eval_output_names():
+    return ['net2/eval/summ_loss']
 
-        coord.request_stop()
-        coord.join(threads)
 
-        print("loss:", loss)
-
-
-def summaries(loss):
-    tf.summary.scalar('net2/eval/loss', loss)
-    return tf.summary.merge_all()
+def eval(logdir1, logdir2):
+    # Load graph
+    model = Net2()
+
+    # dataflow
+    df = Net2DataFlow(hp.test2.data_path, hp.test2.batch_size)
+
+    ckpt1 = tf.train.latest_checkpoint(logdir1)
+    ckpt2 = tf.train.latest_checkpoint(logdir2)
+    session_inits = []
+    if ckpt2:
+        session_inits.append(SaverRestore(ckpt2))
+    if ckpt1:
+        session_inits.append(SaverRestore(ckpt1, ignore=['global_step']))
+    pred_conf = PredictConfig(
+        model=model,
+        input_names=get_eval_input_names(),
+        output_names=get_eval_output_names(),
+        session_init=ChainInit(session_inits))
+    predictor = OfflinePredictor(pred_conf)
+
+    x_mfccs, y_spec, _ = next(df().get_data())
+    summ_loss, = predictor(x_mfccs, y_spec)
+
+    writer = tf.summary.FileWriter(logdir2)
+    writer.add_summary(summ_loss)
+    writer.close()
 
 
 def get_arguments():
     parser = argparse.ArgumentParser()
-    parser.add_argument('case', type=str, help='experiment case name')
+    parser.add_argument('case1', type=str, help='experiment case name of train1')
+    parser.add_argument('case2', type=str, help='experiment case name of train2')
     arguments = parser.parse_args()
     return arguments
 
 
 if __name__ == '__main__':
     args = get_arguments()
-    hp.set_hparam_yaml(args.case)
-    logdir = '{}/train2'.format(hp.logdir)
+    hp.set_hparam_yaml(args.case2)
+    logdir_train1 = '{}/{}/train1'.format(hp.logdir_path, args.case1)
+    logdir_train2 = '{}/{}/train2'.format(hp.logdir_path, args.case2)
 
-    writer = tf.summary.FileWriter(logdir)
-    eval(logdir=logdir, writer=writer)
-    writer.close()
+    eval(logdir1=logdir_train1, logdir2=logdir_train2)
 
-    print("Done")
+    print("Done")