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)