def test_mlsa_filter(fs1, fs2):
np.random.seed(0)
clb = feature.get_analyzer(dataset.get_wav_path(dataset.CLB_WAV, fs=fs1))
slt = feature.get_analyzer(dataset.get_wav_path(dataset.SLT_WAV, fs=fs2))
slt_aligned = kwiiyatta.align(slt, clb)
mcep_diff = copy.copy(slt_aligned.mel_cepstrum)
mcep_diff.data = mcep_diff.data - clb.mel_cepstrum.resample_data(slt.fs)
result = kwiiyatta.apply_mlsa_filter(clb.wavdata, mcep_diff)
expected = kwiiyatta.feature(clb)
if clb.fs > slt.fs:
slt_shape = clb.spectrum_len * slt.fs // clb.fs
expected.spectrum_envelope = \
np.hstack((
feature.override_power(
slt_aligned.reshaped_spectrum_envelope(slt_shape),
clb.spectrum_envelope[:, :slt_shape]
),
clb.spectrum_envelope[:, slt_shape:]
))
else:
expected.spectrum_envelope = \
slt_aligned.resample_spectrum_envelope(clb.fs)
feature.override_spectrum_power(expected, clb)
actual = kwiiyatta.Analyzer(result)
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(expected, actual)
assert_any.between(0.051, f0_diff, 0.078)
assert_any.between(0.32, spec_diff, 0.55)
assert_any.between(0.039, ape_diff, 0.073)
assert_any.between(0.038, mcep_diff, 0.088)
def test_align_even(check):
np.random.seed(0)
a1 = feature.get_analyzer(dataset.CLB_WAV)
a2 = feature.get_analyzer(dataset.SLT_WAV)
mcep1 = a1.mel_cepstrum.data
mcep2 = a2.mel_cepstrum.data
mcep1 = mcep1.reshape(1, *mcep1.shape)
mcep2 = mcep2.reshape(1, *mcep2.shape)
mcep1, mcep2 = DTWAligner(verbose=0).transform((mcep1, mcep2))
exp_m1 = mcep1[0, :, :]
exp_m2 = mcep2[0, :, :]
act1, act2 = kwiiyatta.align_even(a1, a2)
dist_1, _ = fastdtw.fastdtw(exp_m1,
act1.mel_cepstrum.data,
radius=1,
dist=2)
dist_2, _ = fastdtw.fastdtw(exp_m2,
act2.mel_cepstrum.data,
radius=1,
dist=2)
check.round_equal(252, dist_1)
check.round_equal(302, dist_2)
def test_voice_resynthesis_diffvc(check, tmpdir):
result_root = pathlib.Path(tmpdir)
sys.argv = [
sys.argv[0],
str(dataset.CLB_WAV), "--result-dir",
str(result_root), "--mcep", "--mcep-order", "48", "--carrier",
str(dataset.SLT_WAV), "--diffvc"
]
rv.main()
result_file = result_root / 'arctic_a0001.wav'
assert result_file.is_file()
clb = feature.get_analyzer(dataset.CLB_WAV)
slt = feature.get_analyzer(dataset.SLT_WAV)
expected = kwiiyatta.align(clb, slt)
expected.f0 = slt.f0
feature.override_spectrum_power(expected, slt)
expected.aperiodicity = slt.aperiodicity
expected.mel_cepstrum = None
actual = kwiiyatta.analyze_wav(result_file)
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(expected, actual)
check.round_equal(0.10, f0_diff)
check.round_equal(0.36, spec_diff)
check.round_equal(0.076, ape_diff)
check.round_equal(0.081, mcep_diff)
def test_voice_resynthesis_carrier(check, tmpdir):
result_root = pathlib.Path(tmpdir)
sys.argv = [
sys.argv[0],
str(dataset.CLB_WAV), "--result-dir",
str(result_root), "--mcep", "--mcep-order", "48", "--carrier",
str(dataset.SLT_WAV)
]
rv.main()
result_file = result_root / 'arctic_a0001.wav'
assert result_file.is_file()
clb = feature.get_analyzer(dataset.CLB_WAV)
slt = feature.get_analyzer(dataset.SLT_WAV)
expected = kwiiyatta.align(clb, slt)
expected.f0 = slt.f0
actual = kwiiyatta.analyze_wav(result_file)
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(expected, actual)
check.round_equal(0.093, f0_diff)
check.round_equal(0.23, spec_diff)
check.round_equal(0.093, ape_diff)
check.round_equal(0.060, mcep_diff)
def test_analyze_difffile(check):
a1 = feature.get_analyzer(dataset.CLB_WAV)
a2 = feature.get_analyzer(dataset.CLB_WAV2)
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(a1, a2, strict=False)
check.round_equal(0.63, f0_diff)
check.round_equal(1.0, spec_diff)
check.round_equal(0.49, ape_diff)
check.round_equal(0.27, mcep_diff)
def make_expected_feature(wavpath, fs=16000, fullset=False):
src = feature.get_analyzer(
dataset.get_wav_path(dataset.CLB_DIR / wavpath, fullset, fs=fs))
tgt = feature.get_analyzer(
dataset.get_wav_path(dataset.SLT_DIR / wavpath, fullset, fs=fs))
tgt_aligned = kwiiyatta.align(tgt, src)
expected = kwiiyatta.feature(src)
expected.spectrum_envelope = tgt_aligned.spectrum_envelope
feature.override_spectrum_power(expected, src)
return expected
def test_resample_down(fs1, fs2, wavfile, frame_period):
if fs2 < fs1:
fs1, fs2 = fs2, fs1
a1 = feature.get_analyzer(dataset.get_wav_path(wavfile, fs=fs1),
frame_period=frame_period)
a2 = feature.get_analyzer(dataset.get_wav_path(wavfile, fs=fs2),
frame_period=frame_period)
a2_r = kwiiyatta.resample(a2, fs1)
a2._spectrum_envelope = None
a2._aperiodicity = None
a2._mel_cepstrum.data = None
assert a1.fs == a2_r.fs
assert (feature.calc_diff(a2_r.mel_cepstrum.data,
a2.resample_mel_cepstrum(a2_r.fs).data) == 0)
assert feature.calc_diff(a2_r.f0, a2.f0) == 0
assert (feature.calc_powered_diff(a2_r.spectrum_envelope,
a2.resample_spectrum_envelope(
a2_r.fs)) == 0)
assert (feature.calc_diff(a2_r.aperiodicity,
a2.resample_aperiodicity(a2_r.fs)) == 0)
assert a2.mel_cepstrum.order == a2_r.mel_cepstrum.order
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(a1, a2_r)
assert_any.between(0.0012, f0_diff, 0.014)
assert_any.between(0.0025, spec_diff, 0.0094)
assert_any.between(0.0015, ape_diff, 0.048)
assert_any.between(0.011, mcep_diff, 0.031)
a2_r_wav = a2_r.synthesize()
a2_r_s = kwiiyatta.Analyzer(a2_r_wav, frame_period=frame_period)
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(a1, a2_r_s)
assert_any.between(0.055, f0_diff, 0.11)
assert_any.between(0.20, spec_diff, 0.23)
assert_any.between(0.072, ape_diff, 0.10)
assert_any.between(0.038, mcep_diff, 0.056)
f2 = kwiiyatta.feature(a2)
f2.extract_mel_cepstrum()
f2.spectrum_envelope = None
f2_mcep_r = f2.resample_mel_cepstrum(a1.fs)
mcep_diff = feature.calc_diff(a1.mel_cepstrum.data, f2_mcep_r.data)
assert_any.between(0.014, mcep_diff, 0.041)
a2_mcep_r = kwiiyatta.resample(a2.mel_cepstrum, a1.fs)
mcep_diff = feature.calc_diff(a2_mcep_r.data, f2_mcep_r.data)
assert mcep_diff == 0
def test_delta_converter():
a = feature.get_analyzer(dataset.CLB_WAV)
base = {'key': a}
delta_converter = DeltaFeatureConverter(NopConverter())
delta_converter.train(MelCepstrumDataset(base), ['key'])
with pytest.raises(ValueError) as e:
a_fp3 = feature.get_analyzer(dataset.CLB_WAV, frame_period=3)
delta_converter.convert(a_fp3.mel_cepstrum.data[:, 1:], a_fp3)
assert 'frame_period is expected to 5 but 3' == str(e.value)
mcep = a.mel_cepstrum.data[:, 1:]
assert (mcep == delta_converter.convert(mcep, a)).all()
def test_mcep_converter():
a = kwiiyatta.feature(feature.get_analyzer(dataset.CLB_WAV))
base = {'key': copy.copy(a)}
mcep_converter = MelCepstrumFeatureConverter(NopConverter())
mcep_converter.train(base, ['key'])
mcep = feature.get_analyzer(dataset.CLB_WAV).mel_cepstrum
with pytest.raises(ValueError) as e:
a.mel_cepstrum_order = 32
mcep_converter.convert(a.mel_cepstrum)
assert 'order is expected to 24 but 32' == str(e.value)
a.mel_cepstrum_order = 24
mcep = a.mel_cepstrum
mcep._fs = 44100
mcep_converter.expected_convert = \
a.resample_mel_cepstrum(16000).data[:, 1:]
assert mcep_converter.convert(mcep).fs == 16000
def test_delta_dataset():
base = {
'fp5': feature.get_analyzer(dataset.CLB_WAV),
'fp5_2': feature.get_analyzer(dataset.CLB_WAV2),
'fp3': feature.get_analyzer(dataset.CLB_WAV, frame_period=3)
}
mcep_dataset = MelCepstrumDataset(base)
delta_dataset = DeltaFeatureDataset(mcep_dataset)
assert (delta_dataset['fp5'] == delta_features(mcep_dataset['fp5'],
DELTA_WINDOWS)).all()
assert (delta_dataset['fp5_2'] == delta_features(mcep_dataset['fp5_2'],
DELTA_WINDOWS)).all()
with pytest.raises(ValueError) as e:
delta_dataset['fp3']
assert 'frame_period of "fp3" is 3 but others are 5' == str(e.value)
def test_align_even_raw(check):
a1 = feature.get_analyzer(dataset.CLB_WAV)
a2 = feature.get_analyzer(dataset.SLT_WAV)
mcep1 = a1.mel_cepstrum.data
mcep2 = a2.mel_cepstrum.data
mcep1 = mcep1.reshape(1, *mcep1.shape)
mcep2 = mcep2.reshape(1, *mcep2.shape)
mcep1, mcep2 = DTWAligner(verbose=0).transform((mcep1, mcep2))
exp_m1 = mcep1[0, :, :]
exp_m2 = mcep2[0, :, :]
act1, act2 = kwiiyatta.align_even(a1,
a2,
vuv=None,
power='raw',
strict=False,
pad_silence=False)
assert (exp_m1 == act1.mel_cepstrum.data).all()
assert (exp_m2 == act2.mel_cepstrum.data).all()
def test_mcep_dataset():
a = kwiiyatta.feature(feature.get_analyzer(dataset.CLB_WAV))
base = {'order24': copy.copy(a)}
base['order32'] = copy.copy(a)
base['order32'].mel_cepstrum_order = 32
base['fs44'] = copy.copy(a)
base['fs44'].mel_cepstrum._fs = 44100
mcep_dataset = MelCepstrumDataset(base)
mcep_dataset['order24']
assert (a.mel_cepstrum.data[:, 1:] == mcep_dataset['order32']).all()
assert (base['fs44'].resample_mel_cepstrum(16000).data[:, 1:] ==
mcep_dataset['fs44']).all()
def test_feature():
a = feature.get_analyzer(dataset.CLB_WAV)
f = kwiiyatta.feature(a)
assert f == a
f._mel_cepstrum._fs *= 2
assert f != a
f._mel_cepstrum._fs = a.fs
assert f == a
f._mel_cepstrum._frame_period *= 2
assert f != a
f._mel_cepstrum._frame_period = a.frame_period
assert f == a
f.f0 = None
assert f != a
f.f0 = a.f0
f.spectrum_envelope = copy.copy(a.spectrum_envelope)
assert f == a
f.spectrum_envelope[0][0] += 0.001
assert f != a
f.spectrum_envelope[0][0] = a.spectrum_envelope[0][0]
f.aperiodicity = copy.copy(f.aperiodicity)
assert f == a
f.aperiodicity[-1][-1] += 0.001
assert f != a
f.aperiodicity[-1][-1] = a.aperiodicity[-1][-1]
assert f == a
half = len(a.f0) // 2
f0, spec, ape, mcep = a[half]
assert f0 == a.f0[half]
assert (spec == a.spectrum_envelope[half]).all()
assert (ape == a.aperiodicity[half]).all()
assert (mcep == a.mel_cepstrum.data[half]).all()
f = a[:half]
assert len(f.f0) == len(f.spectrum_envelope) == len(f.aperiodicity) == half
assert (f.f0 == a.f0[:half]).all()
assert (f.spectrum_envelope == a.spectrum_envelope[:half]).all()
assert (f.aperiodicity == a.aperiodicity[:half]).all()
assert (f.mel_cepstrum.data == a.mel_cepstrum.data[:half]).all()
def test_reanalyze(wavfile, dtype, fs, frame_period):
a1 = feature.get_analyzer(dataset.get_wav_path(wavfile, dtype=dtype,
fs=fs),
frame_period=frame_period)
assert a1.fs == fs
analyzer_wav = a1.synthesize()
feature_wav = kwiiyatta.feature(a1).synthesize()
assert analyzer_wav.fs == feature_wav.fs
assert (analyzer_wav.data == feature_wav.data).all()
a2 = kwiiyatta.Analyzer(analyzer_wav, frame_period=frame_period)
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(a1, a2)
assert_any.between(0.052, f0_diff, 0.094)
assert_any.between(0.20, spec_diff, 0.22)
assert_any.between(0.063, ape_diff, 0.096)
assert_any.between(0.030, mcep_diff, 0.055)
def test_trimmed_dataset():
def add_margin(data, margin_len=64):
if len(data.shape) == 1:
pad = np.zeros((margin_len, ))
else:
pad = np.zeros((margin_len, data.shape[1]))
return np.concatenate((pad, data, pad), axis=0)
f = kwiiyatta.feature(feature.get_analyzer(dataset.CLB_WAV))
f.f0 = add_margin(f.f0)
f.spectrum_envelope = add_margin(f.spectrum_envelope)
f.aperiodicity = add_margin(f.aperiodicity)
len_f = len(f.f0)
d = TrimmedDataset({'f': f})
len_d = len(d['f'].f0)
assert len_d == len_f - 64
assert np.abs(d['f'].spectrum_envelope[0]).sum() > 0
assert np.abs(d['f'].spectrum_envelope[-1]).sum() > 0
def test_resample_up(fs1, fs2, wavfile, frame_period):
np.random.seed(0)
if fs1 < fs2:
fs1, fs2 = fs2, fs1
a1 = feature.get_analyzer(dataset.get_wav_path(wavfile, fs=fs1),
frame_period=frame_period)
a2 = feature.get_analyzer(dataset.get_wav_path(wavfile, fs=fs2),
frame_period=frame_period)
a2_r = kwiiyatta.resample(a2, fs1)
a2._spectrum_envelope = None
a2._aperiodicity = None
a2._mel_cepstrum.data = None
assert a1.fs == a2_r.fs
assert feature.calc_diff(a2_r.f0, a2.f0) == 0
assert_any.between(
1.7e-8,
feature.calc_powered_diff(a2_r.spectrum_envelope,
a2.resample_spectrum_envelope(a2_r.fs)),
1.4e-7)
assert (feature.calc_diff(a2_r.aperiodicity,
a2.resample_aperiodicity(a2_r.fs)) == 0)
assert_any.between(0.0009,
feature.calc_diff(
a2_r.mel_cepstrum.data,
a2.resample_mel_cepstrum(a2_r.fs).data),
0.004,
sig_dig=1)
assert a2.mel_cepstrum.order == a2_r.mel_cepstrum.order
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(a1, a2_r)
assert_any.between(0.0012, f0_diff, 0.014)
assert_any.between(0.0015, spec_diff, 0.0068)
assert_any.between(0.039, ape_diff, 0.20)
assert_any.between(0.10, mcep_diff, 0.36)
a2_r_wav = a2_r.synthesize()
a2_r_s = kwiiyatta.Analyzer(a2_r_wav, frame_period=frame_period)
f0_diff, spec_diff, ape_diff, mcep_diff = \
feature.calc_feature_diffs(a1, a2_r_s)
assert_any.between(0.050, f0_diff, 0.11)
assert_any.between(0.20, spec_diff, 0.23)
assert_any.between(0.065, ape_diff, 0.32)
assert_any.between(0.047, mcep_diff, 0.16)
f2 = kwiiyatta.feature(a2)
f2.extract_mel_cepstrum()
f2.spectrum_envelope = None
f2_mcep_r = f2.resample_mel_cepstrum(a1.fs)
mcep_diff = feature.calc_diff(a1.mel_cepstrum.data, f2_mcep_r.data)
assert_any.between(0.10, mcep_diff, 0.36)
a2_mcep_r = kwiiyatta.resample(a2.mel_cepstrum, a1.fs)
assert_any.between(0.0009,
feature.calc_diff(a2_mcep_r.data, f2_mcep_r.data),
0.004,
sig_dig=1)
frame_fs2 = a1.spectrum_envelope.shape[1] * fs2 // a1.fs
spec_diff = feature.calc_powered_diff(
a1.spectrum_envelope[:, :frame_fs2],
a2_r.spectrum_envelope[:, :frame_fs2])
assert_any.between(0.00012, spec_diff, 0.55)
