def gpu_decode(feat_list,
gpu,
cvlist=None,
lsd_cvlist=None,
lsdstd_cvlist=None,
cvlist_dv=None,
lsd_cvlist_dv=None,
lsdstd_cvlist_dv=None,
f0rmse_cvlist=None,
f0corr_cvlist=None,
caprmse_cvlist=None,
f0rmse_cvlist_dv=None,
f0corr_cvlist_dv=None,
caprmse_cvlist_dv=None,
cvlist_cyc=None,
lsd_cvlist_cyc=None,
lsdstd_cvlist_cyc=None,
cvlist_cyc_dv=None,
lsd_cvlist_cyc_dv=None,
lsdstd_cvlist_cyc_dv=None,
f0rmse_cvlist_cyc=None,
f0corr_cvlist_cyc=None,
caprmse_cvlist_cyc=None,
f0rmse_cvlist_cyc_dv=None,
f0corr_cvlist_cyc_dv=None,
caprmse_cvlist_cyc_dv=None):
with torch.cuda.device(gpu):
# define model and load parameters
with torch.no_grad():
model_encoder_melsp = GRU_VAE_ENCODER(
in_dim=config.mel_dim,
n_spk=n_spk,
lat_dim=config.lat_dim,
hidden_layers=config.hidden_layers_enc,
hidden_units=config.hidden_units_enc,
kernel_size=config.kernel_size_enc,
dilation_size=config.dilation_size_enc,
causal_conv=config.causal_conv_enc,
bi=False,
ar=False,
pad_first=True,
right_size=config.right_size_enc)
logging.info(model_encoder_melsp)
model_decoder_melsp = GRU_SPEC_DECODER(
feat_dim=config.lat_dim + config.lat_dim_e,
excit_dim=config.excit_dim,
out_dim=config.mel_dim,
n_spk=n_spk,
hidden_layers=config.hidden_layers_dec,
hidden_units=config.hidden_units_dec,
kernel_size=config.kernel_size_dec,
dilation_size=config.dilation_size_dec,
causal_conv=config.causal_conv_dec,
bi=False,
ar=False,
pad_first=True,
right_size=config.right_size_dec)
logging.info(model_decoder_melsp)
model_encoder_excit = GRU_VAE_ENCODER(
in_dim=config.mel_dim,
n_spk=n_spk,
lat_dim=config.lat_dim_e,
hidden_layers=config.hidden_layers_enc,
hidden_units=config.hidden_units_enc,
kernel_size=config.kernel_size_enc,
dilation_size=config.dilation_size_enc,
causal_conv=config.causal_conv_enc,
bi=False,
ar=False,
pad_first=True,
right_size=config.right_size_enc)
logging.info(model_encoder_excit)
model_decoder_excit = GRU_EXCIT_DECODER(
feat_dim=config.lat_dim_e,
cap_dim=config.cap_dim,
n_spk=n_spk,
hidden_layers=config.hidden_layers_lf0,
hidden_units=config.hidden_units_lf0,
kernel_size=config.kernel_size_lf0,
dilation_size=config.dilation_size_lf0,
causal_conv=config.causal_conv_lf0,
bi=False,
ar=False,
pad_first=True,
right_size=config.right_size_lf0)
logging.info(model_decoder_excit)
if (config.spkidtr_dim > 0):
model_spkidtr = SPKID_TRANSFORM_LAYER(
n_spk=n_spk, spkidtr_dim=config.spkidtr_dim)
logging.info(model_spkidtr)
model_encoder_melsp.load_state_dict(
torch.load(args.model)["model_encoder_melsp"])
model_decoder_melsp.load_state_dict(
torch.load(args.model)["model_decoder_melsp"])
model_encoder_excit.load_state_dict(
torch.load(args.model)["model_encoder_excit"])
model_decoder_excit.load_state_dict(
torch.load(args.model)["model_decoder_excit"])
if (config.spkidtr_dim > 0):
model_spkidtr.load_state_dict(
torch.load(args.model)["model_spkidtr"])
model_encoder_melsp.cuda()
model_decoder_melsp.cuda()
model_encoder_excit.cuda()
model_decoder_excit.cuda()
if (config.spkidtr_dim > 0):
model_spkidtr.cuda()
model_encoder_melsp.eval()
model_decoder_melsp.eval()
model_encoder_excit.eval()
model_decoder_excit.eval()
if (config.spkidtr_dim > 0):
model_spkidtr.eval()
for param in model_encoder_melsp.parameters():
param.requires_grad = False
for param in model_decoder_melsp.parameters():
param.requires_grad = False
for param in model_encoder_excit.parameters():
param.requires_grad = False
for param in model_decoder_excit.parameters():
param.requires_grad = False
if (config.spkidtr_dim > 0):
for param in model_spkidtr.parameters():
param.requires_grad = False
count = 0
pad_left = (model_encoder_melsp.pad_left +
model_decoder_excit.pad_left +
model_decoder_melsp.pad_left) * 2
pad_right = (model_encoder_melsp.pad_right +
model_decoder_excit.pad_right +
model_decoder_melsp.pad_right) * 2
outpad_lefts = [None] * 5
outpad_rights = [None] * 5
outpad_lefts[0] = pad_left - model_encoder_melsp.pad_left
outpad_rights[0] = pad_right - model_encoder_melsp.pad_right
outpad_lefts[1] = outpad_lefts[0] - model_decoder_excit.pad_left
outpad_rights[1] = outpad_rights[0] - model_decoder_excit.pad_right
outpad_lefts[2] = outpad_lefts[1] - model_decoder_melsp.pad_left
outpad_rights[2] = outpad_rights[1] - model_decoder_melsp.pad_right
outpad_lefts[3] = outpad_lefts[2] - model_encoder_melsp.pad_left
outpad_rights[3] = outpad_rights[2] - model_encoder_melsp.pad_right
outpad_lefts[4] = outpad_lefts[3] - model_decoder_excit.pad_left
outpad_rights[4] = outpad_rights[3] - model_decoder_excit.pad_right
for feat_file in feat_list:
# reconst. melsp
logging.info("recmelsp " + feat_file)
feat_org = read_hdf5(feat_file, "/log_1pmelmagsp")
logging.info(feat_org.shape)
with torch.no_grad():
feat = F.pad(
torch.FloatTensor(feat_org).cuda().unsqueeze(
0).transpose(1, 2), (pad_left, pad_right),
"replicate").transpose(1, 2)
spk_logits, _, lat_src, _ = model_encoder_melsp(
feat, sampling=False)
spk_logits_e, _, lat_src_e, _ = model_encoder_excit(
feat, sampling=False)
logging.info('input spkpost')
if outpad_rights[0] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[0]:
-outpad_rights[0]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[0]:],
dim=-1), 1))
logging.info('input spkpost_e')
if outpad_rights[0] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[0]:
-outpad_rights[0]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[0]:],
dim=-1), 1))
if config.spkidtr_dim > 0:
src_code = model_spkidtr((torch.ones(
(1, lat_src_e.shape[1])) * spk_idx).cuda().long())
else:
src_code = (torch.ones(
(1, lat_src_e.shape[1])) * spk_idx).cuda().long()
cvlf0_src, _ = model_decoder_excit(src_code, lat_src_e)
if model_decoder_excit.pad_right > 0:
lat_cat = torch.cat((
lat_src_e[:, model_decoder_excit.
pad_left:-model_decoder_excit.pad_right],
lat_src[:, model_decoder_excit.
pad_left:-model_decoder_excit.pad_right]),
2)
else:
lat_cat = torch.cat(
(lat_src_e[:, model_decoder_excit.pad_left:],
lat_src[:, model_decoder_excit.pad_left:]), 2)
if config.spkidtr_dim > 0:
src_code = model_spkidtr((torch.ones(
(1, lat_cat.shape[1])) * spk_idx).cuda().long())
else:
src_code = (torch.ones(
(1, lat_cat.shape[1])) * spk_idx).cuda().long()
cvmelsp_src, _ = model_decoder_melsp(
lat_cat,
y=src_code,
e=cvlf0_src[:, :, :config.excit_dim])
spk_logits, _, lat_rec, _ = model_encoder_melsp(
cvmelsp_src, sampling=False)
spk_logits_e, _, lat_rec_e, _ = model_encoder_excit(
cvmelsp_src, sampling=False)
logging.info('rec spkpost')
if outpad_rights[3] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[3]:
-outpad_rights[3]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[3]:],
dim=-1), 1))
logging.info('rec spkpost_e')
if outpad_rights[3] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[3]:
-outpad_rights[3]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[3]:],
dim=-1), 1))
if config.spkidtr_dim > 0:
src_code = model_spkidtr((torch.ones(
(1, lat_rec_e.shape[1])) * spk_idx).cuda().long())
else:
src_code = (torch.ones(
(1, lat_rec_e.shape[1])) * spk_idx).cuda().long()
cvlf0_cyc, _ = model_decoder_excit(src_code, lat_rec_e)
if model_decoder_excit.pad_right > 0:
lat_cat = torch.cat((
lat_rec_e[:, model_decoder_excit.
pad_left:-model_decoder_excit.pad_right],
lat_rec[:, model_decoder_excit.
pad_left:-model_decoder_excit.pad_right]),
2)
else:
lat_cat = torch.cat(
(lat_rec_e[:, model_decoder_excit.pad_left:],
lat_rec[:, model_decoder_excit.pad_left:]), 2)
if config.spkidtr_dim > 0:
src_code = model_spkidtr((torch.ones(
(1, lat_cat.shape[1])) * spk_idx).cuda().long())
else:
src_code = (torch.ones(
(1, lat_cat.shape[1])) * spk_idx).cuda().long()
cvmelsp_cyc, _ = model_decoder_melsp(
lat_cat,
y=src_code,
e=cvlf0_cyc[:, :, :config.excit_dim])
if outpad_rights[1] > 0:
cvlf0_src = cvlf0_src[:, outpad_lefts[1]:
-outpad_rights[1]]
else:
cvlf0_src = cvlf0_src[:, outpad_lefts[1]:]
if outpad_rights[2] > 0:
cvmelsp_src = cvmelsp_src[:, outpad_lefts[2]:
-outpad_rights[2]]
else:
cvmelsp_src = cvmelsp_src[:, outpad_lefts[2]:]
if outpad_rights[4] > 0:
cvlf0_cyc = cvlf0_cyc[:, outpad_lefts[4]:
-outpad_rights[4]]
else:
cvlf0_cyc = cvlf0_cyc[:, outpad_lefts[4]:]
feat_rec = cvmelsp_src[0].cpu().data.numpy()
feat_cyc = cvmelsp_cyc[0].cpu().data.numpy()
cvmelsp_src = np.array(cvmelsp_src[0].cpu().data.numpy(),
dtype=np.float64)
cvlf0_src = np.array(cvlf0_src[0].cpu().data.numpy(),
dtype=np.float64)
cvmelsp_cyc = np.array(cvmelsp_cyc[0].cpu().data.numpy(),
dtype=np.float64)
cvlf0_cyc = np.array(cvlf0_cyc[0].cpu().data.numpy(),
dtype=np.float64)
logging.info(cvlf0_src.shape)
logging.info(cvmelsp_src.shape)
logging.info(cvlf0_cyc.shape)
logging.info(cvmelsp_cyc.shape)
melsp = np.array(feat_org)
feat_world = read_hdf5(feat_file, "/feat_mceplf0cap")
f0 = np.array(
np.rint(feat_world[:, 0]) * np.exp(feat_world[:, 1]))
codeap = np.array(
np.rint(feat_world[:, 2:3]) *
(-np.exp(feat_world[:, 3:config.full_excit_dim])))
cvf0_src = np.array(
np.rint(cvlf0_src[:, 0]) * np.exp(cvlf0_src[:, 1]))
cvcodeap_src = np.array(
np.rint(cvlf0_src[:, 2:3]) * (-np.exp(cvlf0_src[:, 3:])))
f0_rmse = np.sqrt(np.mean((cvf0_src - f0)**2))
logging.info('F0_rmse_rec: %lf Hz' % (f0_rmse))
cvf0_src_mean = np.mean(cvf0_src)
f0_mean = np.mean(f0)
f0_corr = np.sum((cvf0_src-cvf0_src_mean)*(f0-f0_mean))/\
(np.sqrt(np.sum((cvf0_src-cvf0_src_mean)**2))*np.sqrt(np.sum((f0-f0_mean)**2)))
logging.info('F0_corr_rec: %lf' % (f0_corr))
codeap_rmse = np.sqrt(
np.mean((cvcodeap_src - codeap)**2, axis=0))
for i in range(codeap_rmse.shape[-1]):
logging.info('codeap-%d_rmse_rec: %lf dB' %
(i + 1, codeap_rmse[i]))
cvf0_cyc = np.array(
np.rint(cvlf0_cyc[:, 0]) * np.exp(cvlf0_cyc[:, 1]))
cvcodeap_cyc = np.array(
np.rint(cvlf0_cyc[:, 2:3]) * (-np.exp(cvlf0_cyc[:, 3:])))
f0_rmse_cyc = np.sqrt(np.mean((cvf0_cyc - f0)**2))
logging.info('F0_rmse_cyc: %lf Hz' % (f0_rmse_cyc))
cvf0_cyc_mean = np.mean(cvf0_cyc)
f0_mean = np.mean(f0)
f0_corr_cyc = np.sum((cvf0_cyc-cvf0_cyc_mean)*(f0-f0_mean))/\
(np.sqrt(np.sum((cvf0_cyc-cvf0_cyc_mean)**2))*np.sqrt(np.sum((f0-f0_mean)**2)))
logging.info('F0_corr_cyc: %lf' % (f0_corr_cyc))
codeap_rmse_cyc = np.sqrt(
np.mean((cvcodeap_cyc - codeap)**2, axis=0))
for i in range(codeap_rmse_cyc.shape[-1]):
logging.info('codeap-%d_rmse_cyc: %lf dB' %
(i + 1, codeap_rmse_cyc[i]))
spcidx = np.array(read_hdf5(feat_file, "/spcidx_range")[0])
melsp_rest = (np.exp(melsp) - 1) / 10000
melsp_src_rest = (np.exp(cvmelsp_src) - 1) / 10000
melsp_cyc_rest = (np.exp(cvmelsp_cyc) - 1) / 10000
lsd_arr = np.sqrt(np.mean((20*(np.log10(np.clip(melsp_src_rest[spcidx], a_min=1e-16, a_max=None))\
-np.log10(np.clip(melsp_rest[spcidx], a_min=1e-16, a_max=None))))**2, axis=-1))
lsd_mean = np.mean(lsd_arr)
lsd_std = np.std(lsd_arr)
logging.info("lsd_rec: %.6f dB +- %.6f" % (lsd_mean, lsd_std))
lsd_arr = np.sqrt(np.mean((20*(np.log10(np.clip(melsp_cyc_rest[spcidx], a_min=1e-16, a_max=None))\
-np.log10(np.clip(melsp_rest[spcidx], a_min=1e-16, a_max=None))))**2, axis=-1))
lsd_mean_cyc = np.mean(lsd_arr)
lsd_std_cyc = np.std(lsd_arr)
logging.info("lsd_cyc: %.6f dB +- %.6f" %
(lsd_mean_cyc, lsd_std_cyc))
logging.info('org f0')
logging.info(f0[10:15])
logging.info('rec f0')
logging.info(cvf0_src[10:15])
logging.info('cyc f0')
logging.info(cvf0_cyc[10:15])
logging.info('org cap')
logging.info(codeap[10:15])
logging.info('rec cap')
logging.info(cvcodeap_src[10:15])
logging.info('cyc cap')
logging.info(cvcodeap_cyc[10:15])
dataset = feat_file.split('/')[1].split('_')[0]
if 'tr' in dataset:
logging.info('trn')
f0rmse_cvlist.append(f0_rmse)
f0corr_cvlist.append(f0_corr)
caprmse_cvlist.append(codeap_rmse)
lsd_cvlist.append(lsd_mean)
lsdstd_cvlist.append(lsd_std)
cvlist.append(np.var(melsp_src_rest, axis=0))
logging.info(len(cvlist))
f0rmse_cvlist_cyc.append(f0_rmse_cyc)
f0corr_cvlist_cyc.append(f0_corr_cyc)
caprmse_cvlist_cyc.append(codeap_rmse_cyc)
lsd_cvlist_cyc.append(lsd_mean_cyc)
lsdstd_cvlist_cyc.append(lsd_std_cyc)
cvlist_cyc.append(np.var(melsp_cyc_rest, axis=0))
elif 'dv' in dataset:
logging.info('dev')
f0rmse_cvlist_dv.append(f0_rmse)
f0corr_cvlist_dv.append(f0_corr)
caprmse_cvlist_dv.append(codeap_rmse)
lsd_cvlist_dv.append(lsd_mean)
lsdstd_cvlist_dv.append(lsd_std)
cvlist_dv.append(np.var(melsp_src_rest, axis=0))
logging.info(len(cvlist_dv))
f0rmse_cvlist_cyc_dv.append(f0_rmse_cyc)
f0corr_cvlist_cyc_dv.append(f0_corr_cyc)
caprmse_cvlist_cyc_dv.append(codeap_rmse_cyc)
lsd_cvlist_cyc_dv.append(lsd_mean_cyc)
lsdstd_cvlist_cyc_dv.append(lsd_std_cyc)
cvlist_cyc_dv.append(np.var(melsp_cyc_rest, axis=0))
logging.info('write rec to h5')
outh5dir = os.path.join(
os.path.dirname(os.path.dirname(feat_file)),
args.spk + "-" + args.spk)
if not os.path.exists(outh5dir):
os.makedirs(outh5dir)
feat_file = os.path.join(outh5dir, os.path.basename(feat_file))
logging.info(feat_file + ' ' + args.string_path)
logging.info(feat_rec.shape)
write_hdf5(feat_file, args.string_path, feat_rec)
logging.info('write cyc to h5')
outh5dir = os.path.join(
os.path.dirname(os.path.dirname(feat_file)),
args.spk + "-" + args.spk + "-" + args.spk)
if not os.path.exists(outh5dir):
os.makedirs(outh5dir)
feat_file = os.path.join(outh5dir, os.path.basename(feat_file))
logging.info(feat_file + ' ' + args.string_path)
logging.info(feat_cyc.shape)
write_hdf5(feat_file, args.string_path, feat_cyc)
count += 1
def main():
parser = argparse.ArgumentParser()
# decode setting
parser.add_argument("--model",
required=True,
type=str,
help="GRU_RNN model file")
parser.add_argument("--config",
required=True,
type=str,
help="GRU_RNN configure file")
parser.add_argument("--outdir",
required=True,
type=str,
help="directory to save generated samples")
# other setting
#parser.add_argument("--GPU_device", default=None,
# type=int, help="selection of GPU device")
#parser.add_argument("--GPU_device_str", default=None,
# type=str, help="selection of GPU device")
parser.add_argument("--verbose",
default=VERBOSE,
type=int,
help="log level")
args = parser.parse_args()
#if args.GPU_device is not None or args.GPU_device_str is not None:
# os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
# if args.GPU_device_str is None:
# os.environ["CUDA_VISIBLE_DEVICES"] = str(args.GPU_device)
# else:
# os.environ["CUDA_VISIBLE_DEVICES"] = args.GPU_device_str
os.environ["CUDA_VISIBLE_DEVICES"] = ""
# check directory existence
if not os.path.exists(args.outdir):
os.makedirs(args.outdir)
# set log level
if args.verbose > 0:
logging.basicConfig(
level=logging.INFO,
format=
'%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',
datefmt='%m/%d/%Y %I:%M:%S',
filemode='w',
filename=args.outdir + "/decode.log")
logging.getLogger().addHandler(logging.StreamHandler())
elif args.verbose > 1:
logging.basicConfig(
level=logging.DEBUG,
format=
'%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',
datefmt='%m/%d/%Y %I:%M:%S',
filemode='w',
filename=args.outdir + "/decode.log")
logging.getLogger().addHandler(logging.StreamHandler())
else:
logging.basicConfig(
level=logging.WARN,
format=
'%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s',
datefmt='%m/%d/%Y %I:%M:%S',
filemode='w',
filename=args.outdir + "/decode.log")
logging.getLogger().addHandler(logging.StreamHandler())
logging.warn("logging is disabled.")
# load config
config = torch.load(args.config)
spk_list = config.spk_list.split('@')
n_spk = len(spk_list)
model_epoch = os.path.basename(args.model).split('.')[0].split('-')[1]
logging.info('epoch: ' + model_epoch)
device = torch.device("cpu")
#with torch.cuda.device(0):
# define model and load parameters
with torch.no_grad():
model_spkidtr = SPKID_TRANSFORM_LAYER(n_spk=n_spk,
emb_dim=config.emb_spk_dim,
n_weight_emb=config.n_weight_emb,
conv_emb_flag=True,
spkidtr_dim=config.spkidtr_dim)
logging.info(model_spkidtr)
model_spkidtr.load_state_dict(
torch.load(args.model, map_location=device)["model_spkidtr"])
model_spkidtr.eval()
for param in model_spkidtr.parameters():
param.requires_grad = False
#feat = torch.LongTensor(np.arange(n_spk)).cuda().unsqueeze(0)
feat = torch.LongTensor(np.arange(n_spk)).unsqueeze(0)
logging.info(feat)
logging.info(spk_list)
colormap = np.array(['b', 'r'])
#colormap = np.array(['b'])
male = ['bdl', 'p237', 'p245', 'p251', 'p252', 'p259', 'p274', 'p304', 'p311', 'p326', 'p345', 'p360', 'p363', \
'p226', 'p227', 'p232', 'p237', 'p241', 'p243', 'p245', 'p246', 'p247', 'p251', 'p252', 'p254', 'p255', 'p256', 'p258', 'p259', 'p260', 'p263', 'p270', 'p271', 'p272', 'p273', 'p274', 'p275', 'p278', 'p279', 'p281', 'p284', 'p285', 'p286', 'p287', 'p292', 'p298', 'p302', 'p304', 'p311', 'p315', 'p316', 'p326', \
'SEM1', 'SEM2', 'TFM1', 'TGM1', 'TMM1', 'TEM1', 'TEM2', \
'VCC2SM1', 'VCC2SM2', 'VCC2SM3', 'VCC2TM1', 'VCC2TM2', 'VCC2SM4', \
'okada', 'otake', 'uchino', 'morikawa', 'yamada', 'nuct'] #32
female = ['slt', 'p231', 'p238', 'p248', 'p253', 'p264', 'p265', 'p266', 'p276', 'p305', 'p308', 'p318', 'p335', \
'p225', 'p228', 'p229', 'p230', 'p231', 'p233', 'p234', 'p236', 'p238', 'p239', 'p240', 'p244', 'p248', 'p249', 'p250', 'p253', 'p257', 'p261', 'p262', 'p264', 'p265', 'p266', 'p267', 'p268', 'p269', 'p276', 'p277', 'p282', 'p283', 'p288', 'p293', 'p294', 'p295', 'p297', 'p299', 'p300', 'p301', 'p303', 'p305', \
'SEF1', 'SEF2', 'TEF1', 'TEF2', 'TFF1', 'TGF1', 'TMF1', \
'VCC2SF1', 'VCC2SF2', 'VCC2SF3', 'VCC2TF1', 'VCC2TF2', 'VCC2SF4', \
'taga', 'takada', 'mizokuchi', 'tts'] #30
#male = ['fake', 'morikawa', 'okada', 'otake', 'uchino', 'SEM1', 'SEM2', 'TFM1', 'TGM1', 'TMM1', 'p237', 'p245', 'p251', 'p252', 'p259', 'p274', 'p304', 'p311', 'p326', 'p345', 'p360', 'p363', 'yamada', 'TEM1', 'TEM2']
#female = ['SEF1', 'SEF2', 'naomi', 'mizokuchi', 'taga', 'takada', 'TEF1', 'TEF2', 'TFF1', 'TGF1', 'TMF1', 'p231', 'p238', 'p248', 'p253', 'p264', 'p265', 'p266', 'p276', 'p305', 'p308', 'p318', 'p335']
#male = ['VCC2SM1' , 'VCC2SM2' , 'VCC2SM3' , 'VCC2TM1' , 'VCC2TM2' , 'VCC2SM4']
#female = ['VCC2SF1' , 'VCC2SF2' , 'VCC2SF3' , 'VCC2TF1' , 'VCC2TF2' , 'VCC2SF4']
gender = []
for i in range(n_spk):
#gender.append(0)
if spk_list[i] in male:
gender.append(0)
elif spk_list[i] in female:
gender.append(1)
else:
logging.info('error %s not in gender list' % (spk_list[i]))
exit()
z = F.tanhshrink(
torch.clamp(model_spkidtr.conv(
model_spkidtr.conv_emb(
F.one_hot(feat, num_classes=n_spk).float().transpose(1,
2))),
min=MIN_CLAMP,
max=MAX_CLAMP)).transpose(
1, 2).cpu().data.numpy().astype(np.float64)
#z = F.tanhshrink(model_spkidtr.conv(F.one_hot(feat, num_classes=n_spk).float().transpose(1,2))).transpose(1,2).cpu().data.numpy().astype(np.float64)
#z = F.tanhshrink(torch.clamp(model_spkidtr.conv(F.one_hot(feat, num_classes=self.n_spk).float().transpose(1,2)), min=-32, max=32)).transpose(1,2)
logging.info(z)
logging.info(args.outdir)
#plt.rcParams["figure.figsize"] = (20,11.25) #1920x1080
plt.rcParams["figure.figsize"] = (14.229166667, 11.25) #1366x1080
#plt.rcParams["figure.figsize"] = (11.25,11.25) #1080x1080
#plt.rcParams["figure.figsize"] = (14.229166667,14.229166667) #1366x1366
logging.info("spk-id spk-name x-coord y-coord")
for i in range(n_spk):
logging.info("%d %s %lf %lf", i + 1, spk_list[i], z[0, i, 0],
z[0, i, 1])
#z = z.cpu().data.numpy()
#z = z.data.numpy()
logging.info(z.shape)
x = z[0, :, 0]
y = z[0, :, 1]
fig, ax = plt.subplots()
ax.scatter(x, y, s=40, c=colormap[gender])
#ax.scatter(x, y, s=80, c=colormap[gender])
#ax.scatter(x, y, s=100, c=colormap[gender])
#ax.scatter(x, y, s=120, c=colormap[gender])
#ax.scatter(x, y, s=160, c=colormap[gender])
for i, txt in enumerate(spk_list):
#ax.annotate(txt, (x[i], y[i]))
#ax.annotate(txt, (x[i], y[i]), weight='bold', size=16)
if txt == 'okada':
txt = 'JpnM1'
elif txt == 'otake':
txt = 'JpnM2'
elif txt == 'uchino':
txt = 'JpnM3'
elif txt == 'morikawa':
txt = 'JpnM4'
elif txt == 'yamada':
txt = 'JpnM5'
elif txt == 'nuct':
txt = 'JpnM6'
elif txt == 'taga':
txt = 'JpnF1'
elif txt == 'takada':
txt = 'JpnF2'
elif txt == 'mizokuchi':
txt = 'JpnF3'
elif txt == 'tts':
txt = 'ttsLJSpeech'
#ax.annotate(txt, (x[i], y[i]), weight='bold', size=16)
ax.annotate(txt, (x[i], y[i]), size=14)
#plt.xlim([-0.35, 0.05])
plt.savefig(os.path.join(args.outdir, 'spk_map.png'))
plt.close()
def decode_RNN(feat_list,
gpu,
cvlist=None,
lsd_cvlist_src=None,
lsdstd_cvlist_src=None,
lsd_cvlist_cyc=None,
lsdstd_cvlist_cyc=None,
lsd_cvlist=None,
lsdstd_cvlist=None,
lat_dist_rmse_list=None,
lat_dist_cosim_list=None):
with torch.cuda.device(gpu):
# define model and load parameters
with torch.no_grad():
model_encoder_melsp = GRU_VAE_ENCODER(
in_dim=config.mel_dim,
n_spk=n_spk,
lat_dim=config.lat_dim,
hidden_layers=config.hidden_layers_enc,
hidden_units=config.hidden_units_enc,
kernel_size=config.kernel_size_enc,
dilation_size=config.dilation_size_enc,
causal_conv=config.causal_conv_enc,
pad_first=True,
right_size=config.right_size_enc)
logging.info(model_encoder_melsp)
model_decoder_melsp = GRU_SPEC_DECODER(
feat_dim=config.lat_dim + config.lat_dim_e,
out_dim=config.mel_dim,
n_spk=(config.emb_spk_dim // config.n_weight_emb) *
config.n_weight_emb,
hidden_layers=config.hidden_layers_dec,
hidden_units=config.hidden_units_dec,
kernel_size=config.kernel_size_dec,
dilation_size=config.dilation_size_dec,
causal_conv=config.causal_conv_dec,
pad_first=True,
right_size=config.right_size_dec,
red_dim_upd=config.mel_dim,
pdf_gauss=True)
logging.info(model_decoder_melsp)
model_encoder_excit = GRU_VAE_ENCODER(
in_dim=config.mel_dim,
n_spk=n_spk,
lat_dim=config.lat_dim_e,
hidden_layers=config.hidden_layers_enc,
hidden_units=config.hidden_units_enc,
kernel_size=config.kernel_size_enc,
dilation_size=config.dilation_size_enc,
causal_conv=config.causal_conv_enc,
pad_first=True,
right_size=config.right_size_enc)
logging.info(model_encoder_excit)
model_spkidtr = SPKID_TRANSFORM_LAYER(
n_spk=n_spk,
emb_dim=config.emb_spk_dim,
n_weight_emb=config.n_weight_emb,
conv_emb_flag=True,
spkidtr_dim=config.spkidtr_dim)
logging.info(model_spkidtr)
model_encoder_melsp.load_state_dict(
torch.load(args.model)["model_encoder_melsp"])
model_decoder_melsp.load_state_dict(
torch.load(args.model)["model_decoder_melsp"])
model_encoder_excit.load_state_dict(
torch.load(args.model)["model_encoder_excit"])
model_spkidtr.load_state_dict(
torch.load(args.model)["model_spkidtr"])
model_encoder_melsp.cuda()
model_decoder_melsp.cuda()
model_encoder_excit.cuda()
model_spkidtr.cuda()
model_encoder_melsp.eval()
model_decoder_melsp.eval()
model_encoder_excit.eval()
model_spkidtr.eval()
model_encoder_melsp.remove_weight_norm()
model_decoder_melsp.remove_weight_norm()
model_encoder_excit.remove_weight_norm()
model_spkidtr.remove_weight_norm()
for param in model_encoder_melsp.parameters():
param.requires_grad = False
for param in model_decoder_melsp.parameters():
param.requires_grad = False
for param in model_encoder_excit.parameters():
param.requires_grad = False
for param in model_spkidtr.parameters():
param.requires_grad = False
count = 0
pad_left = (model_encoder_melsp.pad_left +
model_decoder_melsp.pad_left) * 2
pad_right = (model_encoder_melsp.pad_right +
model_decoder_melsp.pad_right) * 2
outpad_lefts = [None] * 3
outpad_rights = [None] * 3
outpad_lefts[0] = pad_left - model_encoder_melsp.pad_left
outpad_rights[0] = pad_right - model_encoder_melsp.pad_right
outpad_lefts[1] = outpad_lefts[0] - model_decoder_melsp.pad_left
outpad_rights[1] = outpad_rights[0] - model_decoder_melsp.pad_right
outpad_lefts[2] = outpad_lefts[1] - model_encoder_melsp.pad_left
outpad_rights[2] = outpad_rights[1] - model_encoder_melsp.pad_right
melfb_t = np.linalg.pinv(
librosa.filters.mel(args.fs, args.fftl, n_mels=config.mel_dim))
temp = 0.675
logging.info(f'temp: {temp}')
for feat_file in feat_list:
# convert melsp
spk_src = os.path.basename(os.path.dirname(feat_file))
logging.info('%s --> %s' % (spk_src, args.spk_trg))
file_trg = os.path.join(
os.path.dirname(os.path.dirname(feat_file)), args.spk_trg,
os.path.basename(feat_file))
trg_exist = False
if os.path.exists(file_trg):
logging.info('exist: %s' % (file_trg))
feat_trg = read_hdf5(file_trg, "/log_1pmelmagsp")
logging.info(feat_trg.shape)
trg_exist = True
feat_org = read_hdf5(feat_file, "/log_1pmelmagsp")
logging.info(feat_org.shape)
logging.info("generate")
with torch.no_grad():
feat = F.pad(
torch.FloatTensor(feat_org).cuda().unsqueeze(
0).transpose(1, 2), (pad_left, pad_right),
"replicate").transpose(1, 2)
spk_logits, _, lat_src, _ = model_encoder_melsp(
feat, sampling=False)
spk_logits_e, _, lat_src_e, _ = model_encoder_excit(
feat, sampling=False)
logging.info('input spkpost')
if outpad_rights[0] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[0]:
-outpad_rights[0]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[0]:],
dim=-1), 1))
logging.info('input spkpost_e')
if outpad_rights[0] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[0]:
-outpad_rights[0]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[0]:],
dim=-1), 1))
if trg_exist:
spk_trg_logits, _, lat_trg, _ = model_encoder_melsp(
F.pad(
torch.FloatTensor(feat_trg).cuda().unsqueeze(
0).transpose(1, 2),
(model_encoder_melsp.pad_left,
model_encoder_melsp.pad_right),
"replicate").transpose(1, 2),
sampling=False)
spk_trg_logits_e, _, lat_trg_e, _ = model_encoder_excit(
F.pad(
torch.FloatTensor(feat_trg).cuda().unsqueeze(
0).transpose(1, 2),
(model_encoder_excit.pad_left,
model_encoder_excit.pad_right),
"replicate").transpose(1, 2),
sampling=False)
logging.info('target spkpost')
logging.info(
torch.mean(F.softmax(spk_trg_logits, dim=-1), 1))
logging.info('target spkpost_e')
logging.info(
torch.mean(F.softmax(spk_trg_logits_e, dim=-1), 1))
_, src_code = model_spkidtr((torch.ones(
(1, lat_src_e.shape[1])) * src_idx).cuda().long())
_, trg_code = model_spkidtr((torch.ones(
(1, lat_src_e.shape[1])) * trg_idx).cuda().long())
lat_cat = torch.cat((lat_src_e, lat_src), 2)
_, cvmelsp_src, _ = model_decoder_melsp(lat_cat,
y=src_code,
temp=temp)
_, cvmelsp, _ = model_decoder_melsp(lat_cat,
y=trg_code,
temp=temp)
trj_lat_cat = lat_cat_src = lat_cat
spk_logits, _, lat_cv, _ = model_encoder_melsp(
cvmelsp, sampling=False)
spk_logits_e, _, lat_cv_e, _ = model_encoder_excit(
cvmelsp, sampling=False)
logging.info('cv spkpost')
if outpad_rights[2] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[2]:
-outpad_rights[2]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits[:, outpad_lefts[2]:],
dim=-1), 1))
logging.info('cv spkpost_e')
if outpad_rights[2] > 0:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[2]:
-outpad_rights[2]],
dim=-1), 1))
else:
logging.info(
torch.mean(
F.softmax(spk_logits_e[:, outpad_lefts[2]:],
dim=-1), 1))
_, src_code = model_spkidtr((torch.ones(
(1, lat_cv_e.shape[1])) * src_idx).cuda().long())
lat_cat = torch.cat((lat_cv_e, lat_cv), 2)
_, cvmelsp_cyc, _ = model_decoder_melsp(lat_cat,
y=src_code,
temp=temp)
#if outpad_rights[0] > 0:
# trj_lat_cat = trj_lat_cat[:,outpad_lefts[0]:-outpad_rights[0]]
#else:
# trj_lat_cat = trj_lat_cat[:,outpad_lefts[0]:-outpad_rights[0]]
if outpad_rights[1] > 0:
cvmelsp_src = cvmelsp_src[:, outpad_lefts[1]:
-outpad_rights[1]]
cvmelsp = cvmelsp[:, outpad_lefts[1]:-outpad_rights[1]]
else:
cvmelsp_src = cvmelsp_src[:, outpad_lefts[1]:]
cvmelsp = cvmelsp[:, outpad_lefts[1]:]
feat_cv = cvmelsp[0].cpu().data.numpy()
#feat_lat = trj_lat_cat[0].cpu().data.numpy()
cvmelsp_src = np.array(cvmelsp_src[0].cpu().data.numpy(),
dtype=np.float64)
cvmelsp = np.array(cvmelsp[0].cpu().data.numpy(),
dtype=np.float64)
cvmelsp_cyc = np.array(cvmelsp_cyc[0].cpu().data.numpy(),
dtype=np.float64)
if trg_exist:
if outpad_rights[1] > 0:
lat_src = lat_cat_src[:, outpad_lefts[0]:
-outpad_rights[0]]
else:
lat_src = lat_cat_src[:, outpad_lefts[0]:]
lat_trg = torch.cat((lat_trg_e, lat_trg), 2)
logging.info(cvmelsp_src.shape)
logging.info(cvmelsp.shape)
logging.info(cvmelsp_cyc.shape)
melsp = np.array(feat_org)
if trg_exist:
logging.info(lat_src.shape)
logging.info(lat_trg.shape)
melsp_trg = np.array(feat_trg)
spcidx = np.array(read_hdf5(feat_file, "/spcidx_range")[0])
melsp_rest = (np.exp(melsp) - 1) / 10000
melsp_cv_rest = (np.exp(cvmelsp) - 1) / 10000
melsp_src_rest = (np.exp(cvmelsp_src) - 1) / 10000
melsp_cyc_rest = (np.exp(cvmelsp_cyc) - 1) / 10000
cvlist.append(np.var(melsp_cv_rest, axis=0))
lsd_arr = np.sqrt(np.mean((20*(np.log10(np.clip(melsp_src_rest[spcidx], a_min=1e-16, a_max=None))\
-np.log10(np.clip(melsp_rest[spcidx], a_min=1e-16, a_max=None))))**2, axis=-1))
lsd_mean = np.mean(lsd_arr)
lsd_std = np.std(lsd_arr)
logging.info("lsd_src_cv: %.6f dB +- %.6f" %
(lsd_mean, lsd_std))
lsd_cvlist_src.append(lsd_mean)
lsdstd_cvlist_src.append(lsd_std)
if trg_exist:
melsp_trg_rest = (np.exp(melsp_trg) - 1) / 10000
spcidx_trg = np.array(
read_hdf5(file_trg, "/spcidx_range")[0])
_, twf_melsp, _, _ = dtw.dtw_org_to_trg(np.array(melsp_cv_rest[spcidx], \
dtype=np.float64), np.array(melsp_trg_rest[spcidx_trg], dtype=np.float64), mcd=-1)
twf_melsp = np.array(twf_melsp[:, 0])
lsd_arr = np.sqrt(np.mean((20*(np.log10(np.clip(melsp_cv_rest[twf_melsp], a_min=1e-16, a_max=None))\
-np.log10(np.clip(melsp_rest[twf_melsp], a_min=1e-16, a_max=None))))**2, axis=-1))
lsd_mean = np.mean(lsd_arr)
lsd_std = np.std(lsd_arr)
logging.info("lsd_trg: %.6f dB +- %.6f" %
(lsd_mean, lsd_std))
lsd_cvlist.append(lsd_mean)
lsdstd_cvlist.append(lsd_std)
spcidx_src = torch.LongTensor(spcidx).cuda()
spcidx_trg = torch.LongTensor(spcidx_trg).cuda()
trj_lat_src = np.array(torch.index_select(
lat_src[0], 0, spcidx_src).cpu().data.numpy(),
dtype=np.float64)
trj_lat_trg = np.array(torch.index_select(
lat_trg[0], 0, spcidx_trg).cpu().data.numpy(),
dtype=np.float64)
aligned_lat_srctrg, _, _, _ = dtw.dtw_org_to_trg(
trj_lat_src, trj_lat_trg)
lat_dist_srctrg = np.mean(
np.sqrt(
np.mean((aligned_lat_srctrg - trj_lat_trg)**2,
axis=0)))
_, _, lat_cdist_srctrg, _ = dtw.dtw_org_to_trg(trj_lat_trg,
trj_lat_src,
mcd=0)
aligned_lat_trgsrc, _, _, _ = dtw.dtw_org_to_trg(
trj_lat_trg, trj_lat_src)
lat_dist_trgsrc = np.mean(
np.sqrt(
np.mean((aligned_lat_trgsrc - trj_lat_src)**2,
axis=0)))
_, _, lat_cdist_trgsrc, _ = dtw.dtw_org_to_trg(trj_lat_src,
trj_lat_trg,
mcd=0)
logging.info("%lf %lf %lf %lf" %
(lat_dist_srctrg, lat_cdist_srctrg,
lat_dist_trgsrc, lat_cdist_trgsrc))
lat_dist_rmse = (lat_dist_srctrg + lat_dist_trgsrc) / 2
lat_dist_cosim = (lat_cdist_srctrg + lat_cdist_trgsrc) / 2
lat_dist_rmse_list.append(lat_dist_rmse)
lat_dist_cosim_list.append(lat_dist_cosim)
logging.info("lat_dist: %.6f %.6f" %
(lat_dist_rmse, lat_dist_cosim))
lsd_arr = np.sqrt(np.mean((20*(np.log10(np.clip(melsp_cyc_rest[spcidx], a_min=1e-16, a_max=None))\
-np.log10(np.clip(melsp_rest[spcidx], a_min=1e-16, a_max=None))))**2, axis=-1))
lsd_mean_cyc = np.mean(lsd_arr)
lsd_std_cyc = np.std(lsd_arr)
logging.info("lsd_cyc: %.6f dB +- %.6f" %
(lsd_mean_cyc, lsd_std_cyc))
lsd_cvlist_cyc.append(lsd_mean_cyc)
lsdstd_cvlist_cyc.append(lsd_std_cyc)
logging.info("synth anasyn")
magsp = np.matmul(melfb_t, melsp_rest.T)
logging.info(magsp.shape)
hop_length = int((args.fs / 1000) * args.shiftms)
win_length = int((args.fs / 1000) * args.winms)
wav = np.clip(
librosa.core.griffinlim(magsp,
hop_length=hop_length,
win_length=win_length,
window='hann'), -1,
0.999969482421875)
wavpath = os.path.join(
args.outdir,
os.path.basename(feat_file).replace(".h5", "_anasyn.wav"))
logging.info(wavpath)
sf.write(wavpath, wav, args.fs, 'PCM_16')
#if trg_exist:
# logging.info("synth anasyn_trg")
# wav = np.clip(pw.synthesize(f0_trg, sp_trg, ap_trg, fs, frame_period=args.shiftms), -1, 1)
# wavpath = os.path.join(args.outdir,os.path.basename(feat_file).replace(".h5","_anasyn_trg.wav"))
# sf.write(wavpath, wav, fs, 'PCM_16')
# logging.info(wavpath)
logging.info("synth gf rec")
recmagsp = np.matmul(melfb_t, melsp_src_rest.T)
logging.info(recmagsp.shape)
wav = np.clip(
librosa.core.griffinlim(recmagsp,
hop_length=hop_length,
win_length=win_length,
window='hann'), -1,
0.999969482421875)
wavpath = os.path.join(
args.outdir,
os.path.basename(feat_file).replace(".h5", "_rec.wav"))
logging.info(wavpath)
sf.write(wavpath, wav, args.fs, 'PCM_16')
logging.info("synth gf cv")
cvmagsp = np.matmul(melfb_t, melsp_cv_rest.T)
logging.info(cvmagsp.shape)
wav = np.clip(
librosa.core.griffinlim(cvmagsp,
hop_length=hop_length,
win_length=win_length,
window='hann'), -1,
0.999969482421875)
wavpath = os.path.join(
args.outdir,
os.path.basename(feat_file).replace(".h5", "_cv.wav"))
logging.info(wavpath)
sf.write(wavpath, wav, args.fs, 'PCM_16')
logging.info('write to h5')
outh5dir = os.path.join(
os.path.dirname(os.path.dirname(feat_file)),
spk_src + "-" + args.spk_trg)
if not os.path.exists(outh5dir):
os.makedirs(outh5dir)
feat_file = os.path.join(outh5dir, os.path.basename(feat_file))
# cv
write_path = args.string_path
logging.info(feat_file + ' ' + write_path)
logging.info(feat_cv.shape)
write_hdf5(feat_file, write_path, feat_cv)
#logging.info('write lat to h5')
#logging.info(feat_file + ' ' + args.string_path+'_lat')
#logging.info(feat_lat.shape)
#write_hdf5(feat_file, args.string_path+'_lat', feat_lat)
count += 1