train script

lib/matlab/Labels

@@ -0,0 +1 @@
+18014,1,float32

lib/matlab/acoustic_feat_ex.m

@@ -0,0 +1,93 @@
+function acoustic_feat_ex( data_dir, save_dir )
+
+rng(0);
+%% Directory setting
+
+% system(['rm -rf ', save_dir]);
+% 
+% system(['mkdir ', save_dir]);
+system(['mkdir ', save_dir, '/Normalize_Factor']);
+system(['mkdir ', save_dir, '/Labels']);
+
+%% Parameter setting
+
+audio_sr = 16000;
+split_num = 1;
+name_mrcg = [save_dir, '/se_mrcg'];
+name_label = [save_dir, '/se_label'];
+
+audio_list = getAllFiles(data_dir, 'FileFilter', '\.wav$');
+label_list = getAllFiles(data_dir, 'FileFilter', '\.mat$');
+
+winlen             = ceil(audio_sr*25*0.001);	%window length (default : 25 ms)
+winstep            = ceil(audio_sr*10*0.001);	%window step (default : 10 ms)
+
+train_mean = 0;
+train_std = 0;
+
+for i = 1:1:length(audio_list)
+    clc
+    fprintf("MRCG extraction %d/%d ...\n", i, length(audio_list));
+    %% Read audio
+
+    noisy_speech = audioread(audio_list{i});  % noisy_speech load
+    noisy_speech = noisy_speech(1:(length(noisy_speech)-mod(length(noisy_speech), split_num)));
+    noisy_speech = reshape(noisy_speech, [], split_num);
+
+    %% Caliculate MRCG
+    mrcg = cell(split_num, 1);
+
+    for j = 1:1:split_num
+        mrcg{j, 1} = MRCG_features(noisy_speech(:, j), audio_sr)';
+        %     imagesc(s(20000:20500,:)*1000)
+    end
+
+    mrcg_mat = cell2mat(mrcg);
+
+    size(mrcg_mat)
+    %% Save normalization factor
+
+    temp_mean = mean(mrcg_mat,1);
+    temp_std = std(mrcg_mat,1,1);
+    save([save_dir, '/Normalize_Factor/normalize_factor_', sprintf('%3.3d', i)],'temp_mean', 'temp_std');
+    train_mean = temp_mean + train_mean;
+    train_std = temp_std + train_std;
+
+    %% Read label
+    label = cell2mat(struct2cell(load(label_list{i})));  % label load
+
+    %% Save framed label & MRCG
+    framed_label = Truelabel2Trueframe( label, winlen, winstep );
+    length(framed_label)
+    if (length(mrcg_mat) > length(framed_label))
+        binary_saver( name_mrcg, mrcg_mat(1:length(framed_label), :), i );
+        binary_saver( name_label, framed_label, i );
+    else
+        binary_saver( name_mrcg, mrcg_mat, i );
+        binary_saver( name_label, framed_label(1:length(mrcg_mat), 1), i );
+    end
+end
+
+disp('MRCG extraction done.')
+%% Save global normalization factor
+
+global_mean = train_mean / length(audio_list);
+global_std = train_std / length(audio_list);
+save([save_dir, '/global_normalize_factor'], 'global_mean', 'global_std');
+
+%% Move label data
+
+feat_list = getAllFiles(save_dir);
+
+for i=1:1:length(feat_list)
+    if ~isempty(strfind(feat_list{i}, 'label'))
+        [pathstr, name, ext] = fileparts(feat_list{i});
+        new_path = [pathstr, '/Labels/', name, ext];
+        movefile(feat_list{i}, new_path);
+    end
+end
+
+end
+
+
+

lib/matlab/afe_test.m

@@ -0,0 +1,5 @@
+clc
+clear
+data_dir = '/home/sbie/github_2/VAD_Toolkit/VAD/data/raw';
+save_dir = '/home/sbie/github_2/VAD_Toolkit/VAD/data/feat';
+acoustic_feat_ex( 0.3, data_dir, save_dir )

lib/python/VAD_DNN.py

@@ -39,10 +39,11 @@
 summary_list = ["cost", "accuracy_SNR_-5", "accuracy_SNR_0", "accuracy_SNR_5", "accuracy_SNR_10",
                 "accuracy_across_all_SNRs"]
 
-learning_rate = 0.00733
+# learning_rate = 0.00733
+learning_rate = 0.0001
 eval_num_batches = 2e5
 SMALL_NUM = 1e-4
-max_epoch = int(51)
+max_epoch = int(1000)
 dropout_rate = 0.5
 
 decay = 0.9  # batch normalization decay factor
@@ -52,8 +53,10 @@
 th = 0.5
 num_hidden_1 = 512
 num_hidden_2 = 512
+model_config = {"w": w, "u": u, "num_hidden_1": num_hidden_1, "num_hidden_2": num_hidden_2}
 
-batch_size = 4096 + 2*w # batch_size = 32
+
+batch_size = 4096 + 2*w  # batch_size = 32
 valid_batch_size = batch_size
 
 assert (w-1) % u == 0, "w-1 must be divisible by u"
@@ -67,6 +70,33 @@
 eval_type = 2
 
 
+def train_config(c_train_dir, c_valid_dir, c_logs_dir, c_batch_size_eval, c_max_epoch, c_mode):
+
+    global file_dir
+    global input_dir
+    global output_dir
+    global valid_file_dir
+    global norm_dir
+    global initial_logs_dir
+    global logs_dir
+    global ckpt_name
+    global batch_size
+    global valid_batch_size
+    global mode
+    global max_epoch
+
+    file_dir = c_train_dir
+    valid_file_dir = c_valid_dir
+    input_dir = file_dir
+    output_dir = file_dir + "/Labels"
+
+    norm_dir = file_dir
+    initial_logs_dir = logs_dir = c_logs_dir
+    batch_size = valid_batch_size = c_batch_size_eval + 2 * w
+    max_epoch = c_max_epoch
+    mode = c_mode
+
+
 def test_config(c_test_dir, c_norm_dir, c_initial_logs_dir, c_batch_size_eval, c_data_len):
 
     global test_file_dir
@@ -304,6 +334,7 @@ def dense_to_one_hot(labels_dense, num_classes=2):
 
 
 class Model(object):
+
     def __init__(self, is_training=True):
 
         self.keep_probability = tf.placeholder(tf.float32, name="keep_probabilty")
@@ -350,13 +381,15 @@ def main(argv=None):
     print("Setting up summary op...")
 
     summary_ph = tf.placeholder(dtype=tf.float32)
-    with tf.variable_scope("Aggregated_Training_Parts"):
+    with tf.variable_scope("Training_procedure"):
 
         cost_summary_op = tf.summary.scalar("cost", summary_ph)
         accuracy_summary_op = tf.summary.scalar("accuracy", summary_ph)
 
-    # train_summary_writer = tf.summary.FileWriter(logs_dir + '/train/', max_queue=2)
-    # valid_summary_writer = tf.summary.FileWriter(logs_dir + '/valid/', max_queue=2)
+    if mode is 'train':
+        train_summary_writer = tf.summary.FileWriter(logs_dir + '/train/', max_queue=2)
+        valid_summary_writer = tf.summary.FileWriter(logs_dir + '/valid/', max_queue=2)
+
     # summary_dic = summary_generation(valid_file_dir)
 
     print("Done")
@@ -376,12 +409,17 @@ def main(argv=None):
 
     if ckpt and ckpt.model_checkpoint_path:  # model restore
         print("Model restored...")
-        saver.restore(sess, initial_logs_dir+ckpt_name)
+
+        if mode is 'train':
+            saver.restore(sess, ckpt.model_checkpoint_path)
+        else:
+            saver.restore(sess, initial_logs_dir+ckpt_name)
+
         print("Done")
     else:
         sess.run(tf.global_variables_initializer())  # if the checkpoint doesn't exist, do initialization
-
-    # train_data_set = dr.DataReader(input_dir, output_dir, norm_dir, w=w, u=u, name="train")  # training data reader initialization
+    if mode is 'train':
+        train_data_set = dr.DataReader(input_dir, output_dir, norm_dir, w=w, u=u, name="train")  # training data reader initialization
 
     if mode is 'train':
 
@@ -400,7 +438,13 @@ def main(argv=None):
 
             if itr % 10 == 0 and itr >= 0:
 
-                train_cost, train_accuracy = sess.run([m_train.cost, m_train.accuracy], feed_dict=feed_dict)
+                # train_cost, train_softpred, train_raw_labels \
+                #     = sess.run([m_train.cost, m_train.softpred, m_train.raw_labels], feed_dict=feed_dict)
+                # fpr, tpr, thresholds = metrics.roc_curve(train_raw_labels, train_softpred, pos_label=1)
+                # train_auc = metrics.auc(fpr, tpr)
+
+                train_cost, train_accuracy \
+                    = sess.run([m_train.cost, m_train.accuracy], feed_dict=feed_dict)
 
                 print("Step: %d, train_cost: %.4f, train_accuracy=%4.4f" % (itr, train_cost, train_accuracy*100))
 
@@ -414,18 +458,28 @@ def main(argv=None):
 
                 saver.save(sess, logs_dir + "/model.ckpt", itr)  # model save
                 print('validation start!')
-                full_evaluation(m_valid, sess, valid_batch_size, valid_file_dir, valid_summary_writer, summary_dic, itr)
+                valid_accuracy, valid_cost = \
+                    utils.do_validation(m_valid, sess, valid_batch_size, valid_file_dir, norm_dir,
+                                        model_config, type='DNN')
+
+                print("valid_cost: %.4f, valid_accuracy=%4.4f" % (valid_cost, valid_accuracy * 100))
+                valid_cost_summary_str = sess.run(cost_summary_op, feed_dict={summary_ph: valid_cost})
+                valid_accuracy_summary_str = sess.run(accuracy_summary_op, feed_dict={summary_ph: valid_accuracy})
+                valid_summary_writer.add_summary(valid_cost_summary_str, itr)  # write the train phase summary to event files
+                valid_summary_writer.add_summary(valid_accuracy_summary_str, itr)
+
+                # full_evaluation(m_valid, sess, valid_batch_size, valid_file_dir, valid_summary_writer, summary_dic, itr)
 
     elif mode is 'test':
         # full_evaluation(m_valid, sess, valid_batch_size, test_file_dir, valid_summary_writer, summary_dic, 0)
 
         final_softout, final_label = utils.vad_test(m_valid, sess, valid_batch_size, test_file_dir, norm_dir, data_len,
                                                     eval_type)
 
-    if data_len is None:
-        return final_softout, final_label
-    else:
-        return final_softout[0:data_len, :], final_label[0:data_len, :]
+        if data_len is None:
+            return final_softout, final_label
+        else:
+            return final_softout[0:data_len, :], final_label[0:data_len, :]
 
 if __name__ == "__main__":
     tf.app.run()

lib/python/feat_ex.py

@@ -0,0 +1,53 @@
+import sys
+
+sys.path.insert(0, './lib/python')
+import VAD_Proposed as Vp
+import VAD_DNN as Vd
+import VAD_bDNN as Vb
+import VAD_LSTM_2 as Vl
+import scipy.io as sio
+import os, getopt
+# norm_dir = "./norm_data"
+# data_dir = "./sample_data"
+# ckpt_name = '/model9918and41.ckpt-2'
+# model_dir = "./saved_model"
+# valid_batch_size = 4134
+
+if __name__ == '__main__':
+
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'h', ["data_dir=", "save_dir="])
+    except getopt.GetoptError as err:
+        print(str(err))
+        sys.exit(1)
+
+    if len(opts) != 2:
+        print("arguments are not enough.")
+        sys.exit(1)
+
+    for opt, arg in opts:
+        if opt == '-h':
+            sys.exit(0)
+        elif opt == '--data_dir':
+            data_dir = str(arg)
+        elif opt == '--save_dir':
+            save_dir = str(arg)
+
+    data_dir = os.path.abspath('../..') + '/data' + data_dir
+    train_data_dir = data_dir + '/train'
+    valid_data_dir = data_dir + '/valid'
+
+    save_dir = os.path.abspath('../..') + '/data' + save_dir
+    train_save_dir = save_dir + '/train'
+    valid_save_dir = save_dir + '/valid'
+
+    os.system("rm -rf " + save_dir)
+    os.system("mkdir " + save_dir)
+    os.system("mkdir " + save_dir + '/train')
+    os.system("mkdir " + save_dir + '/valid')
+
+    os.system("matlab -r \"try acoustic_feat_ex(\'%s\',\'%s\'); catch; end; quit\"" % (train_data_dir, train_save_dir))
+    os.system("matlab -r \"try acoustic_feat_ex(\'%s\',\'%s\'); catch; end; quit\"" % (valid_data_dir, valid_save_dir))
+
+    # os.system("rm -rf")
+    print("done")

lib/python/train.py

@@ -0,0 +1,78 @@
+import sys
+
+sys.path.insert(0, './lib/python')
+import VAD_Proposed as Vp
+import VAD_DNN as Vd
+import VAD_bDNN as Vb
+import VAD_LSTM_2 as Vl
+import scipy.io as sio
+import os, getopt
+# norm_dir = "./norm_data"
+# data_dir = "./sample_data"
+# ckpt_name = '/model9918and41.ckpt-2'
+# model_dir = "./saved_model"
+# valid_batch_size = 4134
+
+if __name__ == '__main__':
+
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], 'hm:e:', ["train_step=", "prj_dir="])
+    except getopt.GetoptError as err:
+        print(str(err))
+        sys.exit(1)
+
+    if len(opts) != 4:
+        print("arguments are not enough.")
+        sys.exit(1)
+
+    for opt, arg in opts:
+        if opt == '-h':
+            sys.exit(0)
+        elif opt == '-m':
+            mode = int(arg)
+        elif opt == '-e':
+            extract_feat = int(arg)
+        elif opt == '--train_step':
+            train_step = int(arg)
+        elif opt == '--prj_dir':
+            prj_dir = str(arg)
+
+    data_dir = prj_dir + '/data/raw'
+    print(data_dir)
+    train_data_dir = data_dir + '/train'
+    valid_data_dir = data_dir + '/valid'
+
+    save_dir = prj_dir + '/data/feat'
+    train_save_dir = save_dir + '/train'
+    valid_save_dir = save_dir + '/valid'
+
+    if extract_feat:
+
+        os.system("rm -rf " + save_dir)
+        os.system("mkdir " + save_dir)
+        os.system("mkdir " + save_dir + '/train')
+        os.system("mkdir " + save_dir + '/valid')
+        os.system(
+            "matlab -r \"try acoustic_feat_ex(\'%s\',\'%s\'); catch; end; quit\"" % (train_data_dir, train_save_dir))
+        os.system(
+            "matlab -r \"try acoustic_feat_ex(\'%s\',\'%s\'); catch; end; quit\"" % (valid_data_dir, valid_save_dir))
+
+        train_norm_dir = save_dir + '/train/global_normalize_factor.mat'
+        test_norm_dir = prj_dir + '/norm_data/global_normalize_factor.mat'
+
+        os.system("cp %s %s" % (train_norm_dir, test_norm_dir))
+
+    if mode == 0:
+
+        logs_dir = prj_dir + '/logs'
+        os.system("rm -rf " + logs_dir + '/train')
+        os.system("rm -rf " + logs_dir + '/valid')
+        os.system("mkdir " + logs_dir + '/train')
+        os.system("mkdir " + logs_dir + '/valid')
+
+        Vd.train_config(save_dir+'/train', save_dir+'/valid', prj_dir+'/logs', 256,
+                        train_step, 'train')
+
+        Vd.main()
+    # os.system("rm -rf")
+    print("done")