refactor until can run vae from scratch

Author: huang18

.gitignore

@@ -1,3 +1,6 @@
+data/vcc2018/wav
+data/vcc2018/bin
+data/vcc2018/stats
 logdir
 __init__.py
 __pycache__

architectures/architecture-vae.json

@@ -3,9 +3,10 @@
     "model_module": "model.vae",
     "trainer": "VAETrainer",
     "trainer_module": "trainer.vae",
-    "stat_dir": "/mnt/md1/datasets/vcc2018/world/etc-new",
-    "spklist": "/mnt/md1/datasets/vcc2018/world/etc/speakers.tsv",
+    "stats": "./data/vcc2018/stats/stats.h5",
+    "spklist": "./data/vcc2018/conf/spk.list",
 
+    "feat_type": "sp",
     "z_dim": 16,
 	"y_dim": 12,
 	"y_emb_dim": 16,
@@ -24,10 +25,11 @@
         }
     },
 	"training": {
-        "train_file_pattern": ["/mnt/md1/datasets/vcc2018/world/bin-dynamic/VAD/tr/*/[12]00[0-6]?.bin",
-                               "/mnt/md1/datasets/vcc2018/world/bin-dynamic/VAD/tr/*/[12]0070.bin"],
-        "valid_file_pattern": ["/mnt/md1/datasets/vcc2018/world/bin-dynamic/VAD/tr/*/[12]007[1-9].bin",
-                               "/mnt/md1/datasets/vcc2018/world/bin-dynamic/VAD/tr/*/[12]008[0-1].bin"],
+        "feat_type": "sp",
+        "train_file_pattern": ["./data/vcc2018/bin/VAD/*/[12]00[0-6]?.bin",
+                               "./data/vcc2018/bin/VAD/*/[12]0070.bin"],
+        "valid_file_pattern": ["./data/vcc2018/bin/VAD/*/[12]007[1-9].bin",
+                               "./data/vcc2018/bin/VAD/*/[12]008[0-1].bin"],
 		"batch_size": 16,
         "crop_length": 128, 
 		"lr": 1e-4,
@@ -39,30 +41,24 @@
         "log_freq": 1000
 	},
     "conversion": {
-        "input": "sp",
-        "output": "sp",
-        "test_file_pattern": "/mnt/md1/datasets/vcc2018/world/bin-dynamic/no_VAD/ev/{}/*.bin"
+        "test_file_pattern": "./data/vcc2018/bin/no_VAD/{}/3*.bin"
     },
     "feat_param":{
         "fs": 22050,
         "shiftms": 5,
         "fftl": 1024,
         "mcep_alpha": 0.455,
-        "sp_dim": 513,
-        "mcc_dim": 34,
-        "feat_dim": 2710,
+        "mcep_dim": 34,
+        "feat_dim": 1064,
         "dim":{
             "sp": 513,
-            "mcc": 34,
-            "feat": 2710
+            "mcep": 34,
+            "feat": 1064
         }
     },
-    "normalizer_files":{
+    "normalizer":{
         "sp": {
-            "type": "minmax",
-            "dim": null,
-            "max": "sp_max.npf",
-            "min": "sp_min.npf"
+            "type": ["minmax"]
         }
     }
 }

convert.py

@@ -1,43 +1,60 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Convert FEATURES with trained models.
+# By Wen-Chin Huang 2019.06
+
 import json
 import os
 
 import tensorflow as tf
 import numpy as np
 
-from datetime import datetime
 from importlib import import_module
 
 import argparse
 import logging
 
 import sys
 from preprocessing.vcc2018.feature_reader import Whole_feature_reader
-from preprocessing.normalizer import MinMaxScaler
+from preprocessing.normalizer import MinMaxScaler, StandardScaler
 from preprocessing.utils import read_hdf5, read_txt
 from util.wrapper import load, get_default_logdir_output
 
 def main():
 
     parser = argparse.ArgumentParser(
-        description="convert files.")
+        description="Conversion.")
     parser.add_argument(
         "--logdir", required=True, type=str,
         help="path of log directory")
     parser.add_argument(
         "--checkpoint", default=None, type=str,
         help="path of checkpoint")
+    
     parser.add_argument(
         "--src", default=None, required=True, type=str,
         help="source speaker")
     parser.add_argument(
         "--trg", default=None, required=True, type=str,
         help="target speaker")
-    parser.add_argument('--stat_dir', type=str,
-        default='/mnt/md1/datasets/vcc2018/world/etc-new',
-        help='configuration directory')
-    parser.add_argument('--file_pattern', type=str,
-        default='/mnt/md1/datasets/vcc2018/world/bin-dynamic/no_VAD/ev/{}/*.bin',
-        help='file pattern')
+    parser.add_argument(
+        "--type", default='test', type=str,
+        help="test or valid (default is test)")
+    
+    
+    parser.add_argument(
+        "--input_feat", required=True, 
+        type=str, help="input feature type")
+    parser.add_argument(
+        "--output_feat", required=True, 
+        type=str, help="output feature type")
+    parser.add_argument(
+        "--mcd", action='store_true',
+        help="calculate mcd or not")
+    parser.add_argument(
+        "--syn", action='store_true',
+        help="synthesize voice or not")
     args = parser.parse_args()
 
     # make exp directory
@@ -70,41 +87,42 @@ def main():
     module = import_module(arch['model_module'], package=None)
     MODEL = getattr(module, arch['model'])
 
-    input_feat = arch['conversion']['input']
+    input_feat = args.input_feat
     input_feat_dim = arch['feat_param']['dim'][input_feat]
-    output_feat = arch['conversion']['output']
+    output_feat = args.output_feat
 
     # read speakers
     spk_list = read_txt(arch['spklist'])
 
     # Load statistics, normalize and NCHW
     normalizers = {}
-    for k in arch['normalizer_files']:
-        if (arch['normalizer_files'][k]['max'] is not None
-            or arch['normalizer_files'][k]['max'] is not None):
-            normalizer = MinMaxScaler(
-                xmax=np.fromfile(os.path.join(arch['stat_dir'], arch['normalizer_files'][k]['max'])),
-                xmin=np.fromfile(os.path.join(arch['stat_dir'], arch['normalizer_files'][k]['min'])),
-            )
-            normalizers[k] = normalizer
+    for k in arch['normalizer']:
+        normalizers[k] = {}
+        for norm_type in arch['normalizer'][k]['type']:
+            if norm_type == 'minmax':
+                normalizer = MinMaxScaler(
+                    xmax=read_hdf5(arch['stats'], '/max/' + k),
+                    xmin=read_hdf5(arch['stats'], '/min/' + k),
+                )
+            elif norm_type == 'meanvar':
+                normalizer = StandardScaler(
+                    mu=read_hdf5(arch['stats'], '/mean/' + k),
+                    std=read_hdf5(arch['stats'], '/scale/' + k),
+                )
+
+            normalizers[k][norm_type] = normalizer
 
     # Define placeholders
     x_pl = tf.placeholder(tf.float32, [None, input_feat_dim])
-    if input_feat in normalizers:
-        x = normalizers[input_feat].forward_process(x_pl)
-    else:
-        x = x_pl
-    x = tf.expand_dims(tf.expand_dims(x, 1), -1)
+    
     yh_pl = tf.placeholder(dtype=tf.int64, shape=[1,])
-    yh = yh_pl * tf.ones(shape=[tf.shape(x)[0],], dtype=tf.int64)
+    yh = yh_pl * tf.ones(shape=[tf.shape(x_pl)[0],], dtype=tf.int64)
+    yh = tf.expand_dims(yh, 0)
 
     # Define model
-    model = MODEL(arch)
-    z = model.encode(x)
+    model = MODEL(arch, normalizers)
+    z, _ = model.encode(x_pl)
     xh = model.decode(z, yh)
-    xh = tf.squeeze(xh)
-    if output_feat in normalizers:
-        xh = normalizers[output_feat].backward_process(xh)
 
     # make directories for output
     tf.gfile.MakeDirs(os.path.join(output_dir, 'latent'))
@@ -123,7 +141,16 @@ def main():
             _, ckpt = os.path.split(args.checkpoint)
             load(saver, sess, args.logdir, ckpt=ckpt)
 
-        files = sorted(tf.gfile.Glob(arch['conversion']['test_file_pattern'].format(args.src)))
+        # get feature list, either validation set or test set
+        if args.type == 'test':
+            files = tf.gfile.Glob(arch['conversion']['test_file_pattern'].format(args.src))
+        elif args.type == 'valid':
+            files = []
+            for p in arch['training']['valid_file_pattern']:
+                files.extend(tf.gfile.Glob(p.replace('*', args.src)))
+        files = sorted(files)
+
+        # conversion
         for f in files:
             basename = os.path.split(f)[-1]
             path_to_latent = os.path.join(output_dir, 'latent', '{}-{}-{}'.format(args.src, args.trg, basename))
@@ -143,6 +170,26 @@ def main():
                 fp.write(latent.tostring())
             with open(path_to_cvt, 'wb') as fp:
                 fp.write(cvt.tostring())
+    
+    # optionally calculate MCD
+    if args.mcd:
+        cmd = "python ./mcd_calculate.py" + \
+                    " --type " + args.type + \
+                    " --logdir " + output_dir + \
+                    " --input_feat " + input_feat + \
+                    " --output_feat " + output_feat
+        print(cmd)
+        os.system(cmd)
+    
+    # optionally synthesize waveform
+    if args.syn:
+        cmd = "python ./synthesize.py" + \
+                    " --type " + args.type + \
+                    " --logdir " + output_dir + \
+                    " --input_feat " + input_feat + \
+                    " --output_feat " + output_feat
+        print(cmd)
+        os.system(cmd)
 
 if __name__ == '__main__':
     main()

data/download.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# download
+python download_speech_corpus.py downloader_conf/vcc2018.yml
+
+# change directory names
+mv wav vcc2018
+cd vcc2018/wav
+find . -type d -name "VCC2*" | while read f; do mv $f $(echo $f | sed 's/VCC2//'); done
+cd ../../