def get_model():
with open(get_weight_path('melgan_config.yml')) as f:
config = yaml.load(f, Loader=yaml.Loader)
config = MelGANGeneratorConfig(**config["generator_params"])
melgan = TFMelGANGenerator(config=config, name="melgan_generator")
melgan._build()
melgan.load_weights(get_weight_path('melgan-1M6.h5'))
return melgan
def load_mb_melgan(config_path, model_path):
with open(config_path) as f:
raw_config = yaml.load(f, Loader=yaml.Loader)
mb_melgan_config = MultiBandMelGANGeneratorConfig(
**raw_config["generator_params"])
mb_melgan = TFMelGANGenerator(config=mb_melgan_config,
name="melgan_generator")
mb_melgan._build()
mb_melgan.load_weights(model_path)
pqmf = TFPQMF(config=mb_melgan_config, name="pqmf")
return (mb_melgan, pqmf)
def _load_melgan(self, path='./model_files/melgan'):
# initialize melgan model for vocoding
config = os.path.join(path, 'config.yml')
with open(config) as f:
melgan_config = yaml.load(f, Loader=yaml.Loader)
melgan_config = MelGANGeneratorConfig(
**melgan_config["generator_params"])
melgan = TFMelGANGenerator(config=melgan_config,
name='melgan_generator')
melgan._build()
weights = os.path.join(path, 'generator-1670000.h5')
melgan.load_weights(weights)
return melgan
def test_multi_band_melgan(dict_g):
args_g = make_multi_band_melgan_generator_args(**dict_g)
args_g = MultiBandMelGANGeneratorConfig(**args_g)
generator = TFMelGANGenerator(args_g, name="multi_band_melgan")
generator._build()
pqmf = TFPQMF(args_g, name="pqmf")
fake_mels = tf.random.uniform(shape=[1, 100, 80], dtype=tf.float32)
fake_y = tf.random.uniform(shape=[1, 100 * 256, 1], dtype=tf.float32)
y_hat_subbands = generator(fake_mels)
y_hat = pqmf.synthesis(y_hat_subbands)
y_subbands = pqmf.analysis(fake_y)
assert np.shape(y_subbands) == np.shape(y_hat_subbands)
assert np.shape(fake_y) == np.shape(y_hat)
def main():
"""Run melgan decoding from folder."""
parser = argparse.ArgumentParser(
description="Generate Audio from melspectrogram with trained melgan "
"(See detail in example/melgan/decode_melgan.py)."
)
parser.add_argument(
"--rootdir",
default=None,
type=str,
required=True,
help="directory including ids/durations files.",
)
parser.add_argument(
"--outdir", type=str, required=True, help="directory to save generated speech."
)
parser.add_argument(
"--checkpoint", type=str, required=True, help="checkpoint file to be loaded."
)
parser.add_argument(
"--use-norm", type=int, default=1, help="Use norm or raw melspectrogram."
)
parser.add_argument("--batch-size", type=int, default=8, help="batch_size.")
parser.add_argument(
"--config",
default=None,
type=str,
required=True,
help="yaml format configuration file. if not explicitly provided, "
"it will be searched in the checkpoint directory. (default=None)",
)
parser.add_argument(
"--verbose",
type=int,
default=1,
help="logging level. higher is more logging. (default=1)",
)
args = parser.parse_args()
# set logger
if args.verbose > 1:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
)
elif args.verbose > 0:
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
)
else:
logging.basicConfig(
level=logging.WARN,
format="%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s",
)
logging.warning("Skip DEBUG/INFO messages")
# check directory existence
if not os.path.exists(args.outdir):
os.makedirs(args.outdir)
# load config
with open(args.config) as f:
config = yaml.load(f, Loader=yaml.Loader)
config.update(vars(args))
if config["format"] == "npy":
mel_query = "*-norm-feats.npy" if args.use_norm == 1 else "*-raw-feats.npy"
mel_load_fn = np.load
else:
raise ValueError("Only npy is supported.")
# define data-loader
dataset = MelDataset(
root_dir=args.rootdir,
mel_query=mel_query,
mel_load_fn=mel_load_fn,
)
dataset = dataset.create(batch_size=args.batch_size)
# define model and load checkpoint
melgan = TFMelGANGenerator(
config=MelGANGeneratorConfig(**config["generator_params"]), name="melgan"
)
melgan._build()
melgan.load_weights(args.checkpoint)
for data in tqdm(dataset, desc="[Decoding]"):
utt_ids, mels, mel_lengths = data["utt_ids"], data["mels"], data["mel_lengths"]
# melgan inference.
generated_audios = melgan(mels)
# convert to numpy.
generated_audios = generated_audios.numpy() # [B, T]
# save to outdir
for i, audio in enumerate(generated_audios):
utt_id = utt_ids[i].numpy().decode("utf-8")
sf.write(
os.path.join(args.outdir, f"{utt_id}.wav"),
audio[: mel_lengths[i].numpy() * config["hop_size"]],
config["sampling_rate"],
"PCM_16",
)
from tensorflow_tts.configs import MelGANGeneratorConfig
from tensorflow_tts.models import TFTacotron2
from tensorflow_tts.models import TFMelGANGenerator
from tensorflow_tts.models import TFMBMelGANGenerator
from tensorflow_tts.configs import MultiBandMelGANGeneratorConfig
from tensorflow_tts.inference import AutoProcessor
from IPython.display import Audio
print(tf.__version__) # 2.5.0-dev20210103
# initialize melgan model 正常的发音
with open( config_lp.multiband_melgan_baker ) as f:
melgan_config = yaml.load(f, Loader=yaml.Loader)
melgan_config = MelGANGeneratorConfig(**melgan_config["multiband_melgan_generator_params"])
melgan = TFMelGANGenerator(config=melgan_config, name='mb_melgan')
melgan._build()
melgan.load_weights(config_lp.multiband_melgan_pretrained_path)
# # Concrete Function
# melgan_concrete_function = melgan.inference_tflite.get_concrete_function()
# converter = tf.lite.TFLiteConverter.from_concrete_functions(
# [melgan_concrete_function]
# )
# converter.optimizations = [tf.lite.Optimize.DEFAULT]
# converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS,
# tf.lite.OpsSet.SELECT_TF_OPS]
# tflite_model = converter.convert()
# # Save the TF Lite model.
# with open('./gen_model/melgan_baker.tflite', 'wb') as f:
# f.write(tflite_model)
# print('Model size is %f MBs.' % (len(tflite_model) / 1024 / 1024.0) )
