def test_get_best_cost(self, mock_delta): mock_delta.return_value = 25 candidate = (172, 0.542) params = raptparams.Raptparams() params.original_audio = (44100, [2.0] * 73000) cost = pyrapt._get_best_cost(candidate, 25, [], 100, params) self.assertEqual(50, cost)
def test_get_delta_cost(self): cand1 = (172, 0.542) cand2 = (0, 0.0) prev_cand1 = (10, (215, 0.211)) prev_cand2 = (10, (0, 0.0)) params = raptparams.Raptparams() with patch('pyrapt.pyrapt._get_unvoiced_to_unvoiced_cost') as mok_cost1: mok_cost1.return_value = 5 cost = pyrapt._get_delta_cost(cand2, prev_cand2, 25, params) self.assertEquals(5, cost) mok_cost1.assert_called_once_with(prev_cand2) with patch('pyrapt.pyrapt._get_voiced_to_unvoiced_cost') as mok_cost2: mok_cost2.return_value = 10 cost = pyrapt._get_delta_cost(cand2, prev_cand1, 25, params) self.assertEquals(10, cost) mok_cost2.assert_called_once_with(cand2, prev_cand1, 25, params) with patch('pyrapt.pyrapt._get_unvoiced_to_voiced_cost') as mok_cost3: mok_cost3.return_value = 15 cost = pyrapt._get_delta_cost(cand1, prev_cand2, 25, params) self.assertEquals(15, cost) mok_cost3.assert_called_once_with(cand1, prev_cand2, 25, params) with patch('pyrapt.pyrapt._get_voiced_to_voiced_cost') as mok_cost4: mok_cost4.return_value = 25 cost = pyrapt._get_delta_cost(cand1, prev_cand1, 25, params) self.assertEquals(25, cost) mok_cost4.assert_called_once_with(cand1, prev_cand1, params)
def test_rms_ratio(self): # TODO: mock hanning window vals # start with basic test - if samples are all the same the frames will # match exactly and rms ratio will just be 1 params = raptparams.Raptparams() params.original_audio = (2000, [2.0] * 73000) params.samples_per_frame = 5 params.hanning_window_length = 60 params.hanning_window_vals = numpy.hanning(60) params.rms_offset = 40 result = pyrapt._get_rms_ratio(100, params) self.assertEqual(1.0, result) # now test one where amp is increasing (rms ratio should be > 1) increasing_audio = [2.0] * 73000 increasing_audio[540:600] = [4.0] * 60 params.original_audio = (2000, increasing_audio) result = pyrapt._get_rms_ratio(100, params) self.assertGreater(result, 1.0) # now test where amp is decreasing (rms ratio should be btwn 0 and 1) decreasing_audio = [2.0] * 73000 decreasing_audio[540:600] = [1.0] * 60 params.original_audio = (2000, decreasing_audio) result = pyrapt._get_rms_ratio(100, params) self.assertGreater(result, 0.0) self.assertLess(result, 1.0)
def test_get_marked_results(self): candidates = ([0.7, 0.2, 0.6, 0.8], 1.0) params = (raptparams.Raptparams(), nccfparams.Nccfparams()) params[1].shortest_lag_per_frame = 7 params[0].min_acceptable_peak_val = 0.5 params[0].max_hypotheses_per_frame = 19 marked_values = pyrapt._get_marked_results(candidates, params, False) self.assertEqual(3, len(marked_values)) self.assertEqual((9, 0.6), marked_values[1])
def test_determine_state_per_frame(self, mock_process): mock_process.return_value = [[(25, (172, 0.5423))]] * 166 raptparam = raptparams.Raptparams() nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166 candidates = pyrapt._determine_state_per_frame(nccf_results, raptparam, 44100) self.assertEqual(166, len(candidates)) mock_process.assert_called_once_with(165, [], nccf_results, raptparam, 44100)
def test_process_candidates(self, mock_calc_frame): mock_calc_frame.return_value = [(25, (172, 0.542)), (55, (770, 0.672))] raptparam = raptparams.Raptparams() nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166 candidates = pyrapt._process_candidates(165, [], nccf_results, raptparam, 44100) mock_calc_frame.assert_called_with(ANY, ANY, nccf_results, raptparam, 44100) self.assertEqual(166, len(candidates))
def test_nccf_firstpass(self, mock_frame_results): mock_frame_results.return_value = [(8, 0.7), (12, 0.8), (21, 0.6)] # TODO: This is with default params. Do it with passed in ones as well sample_rate = 2004 audio_data = numpy.full(3346, 5.0) params = raptparams.Raptparams() candidates = pyrapt._first_pass_nccf((sample_rate, audio_data), params) self.assertEqual(166, len(candidates)) self.assertEqual(3, len(candidates[0])) self.assertEqual(0.8, candidates[34][1][1])
def test_get_marked_results_above_max(self): candidates = ([0.7, 0.2, 0.6, 0.8, 0.9, 0.5], 1.0) params = (raptparams.Raptparams(), nccfparams.Nccfparams()) params[1].shortest_lag_per_frame = 7 params[0].min_acceptable_peak_val = 0.5 params[0].max_hypotheses_per_frame = 5 marked_values = pyrapt._get_marked_results(candidates, params, False) self.assertEqual(4, len(marked_values)) self.assertEqual((7, 0.7), marked_values[0]) self.assertEqual((11, 0.9), marked_values[3]) self.assertEqual((10, 0.8), marked_values[2])
def test_get_marked_results_firstpass(self, mock_get_peak): candidates = ([0.7, 0.2, 0.6, 0.8], 1.0) params = (raptparams.Raptparams(), nccfparams.Nccfparams()) params[1].shortest_lag_per_frame = 7 params[0].min_acceptable_peak_val = 0.5 params[0].max_hypotheses_per_frame = 19 mock_get_peak.return_value = (9, 0.6) marked_values = pyrapt._get_marked_results(candidates, params, True) self.assertEqual(3, len(marked_values)) self.assertEqual((9, 0.6), marked_values[1]) mock_get_peak.assert_called_with(ANY, ANY, ANY)
def test_unvoiced_to_voiced(self, mock_rms): mock_rms.return_value = 2.0 candidate = (709, 0.733) prev_entry = (0.373, (650, 0.841)) params = raptparams.Raptparams() params.transition_cost = 10.0 params.amp_mod_transition_cost = 4.0 cost = pyrapt._get_unvoiced_to_voiced_cost(candidate, prev_entry, 100, params) mock_rms.assert_called_once_with(100, params) self.assertEqual(12.373, cost)
def test_get_freq_estimate(self, mock_determine_state): mock_determine_state.return_value = [75] * 166 raptparam = raptparams.Raptparams() nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166 results = pyrapt._get_freq_estimate(nccf_results, raptparam, 44100) mock_determine_state.assert_called_once_with(nccf_results, raptparam, 44100) self.assertEqual(166, len(results)) # now try it when returned results contain unvoiced hypothesis mock_determine_state.return_value = [50, 0, 75] results = pyrapt._get_freq_estimate(nccf_results, raptparam, 44100) self.assertEqual(0.0, results[1])
def test_get_results_for_frame(self, mock_get_for_all_lags): mock_get_for_all_lags.return_value = ([0.2] * 35, 0.3) audio = (2004, numpy.full(3346, 5.0)) params = (raptparams.Raptparams(), nccfparams.Nccfparams()) lag_range = 8 with patch('pyrapt.pyrapt._get_marked_results') as mock_mark: mock_mark.return_value = [(9, 0.7), (15, 0.8), (17, 0.6)] results = pyrapt._get_firstpass_frame_results( audio, 5, lag_range, params) mock_mark.assert_called_once_with(ANY, ANY, True) self.assertEqual(3, len(results)) self.assertEqual(0.8, results[1][1])
def test_get_correlation(self): audio = (10, numpy.array([0, 1, 2, 3, 4, 5, 6, 7])) params = (raptparams.Raptparams(), nccfparams.Nccfparams()) params[1].samples_per_frame = 2 params[1].samples_correlated_per_lag = 5 correlation = pyrapt._get_correlation(audio, 0, 1, params) self.assertEqual(0.816496580927726, correlation) # Now try with additive constant added in denominator # (only added for 2nd pass NCCF calc) params[0].additive_constant = 12 correlation = pyrapt._get_correlation(audio, 0, 1, params, False) self.assertEqual(0.7856742013183862, correlation)
def test_get_correlations_for_all_lags(self, mock_get_correlation): mock_get_correlation.return_value = 0.4 audio = (2004, numpy.full(3346, 5.0)) params = (raptparams.Raptparams(), nccfparams.Nccfparams()) params[1].samples_correlated_per_lag = 20 params[1].samples_per_frame = 20 params[1].shortest_lag_per_frame = 10 lag_range = 8 results = pyrapt._get_correlations_for_all_lags( audio, 5, lag_range, params) self.assertEqual(0.4, results[1]) self.assertEqual(8, len(results[0])) self.assertEqual(0.4, results[0][7]) mock_get_correlation.assert_called_with(ANY, ANY, ANY, ANY)
def test_calculate_params_all_params(self, mock_hanning): params = raptparams.Raptparams() self.assertEqual(None, params.original_audio) self.assertEqual(None, params.samples_per_frame) mock_hanning.return_value = [1, 2, 3, 4, 5] audio = (44100, [5.0] * 7000) down_audio = (2000, [5.0] * 700) pyrapt._calculate_params(params, audio, down_audio) mock_hanning.assert_called_once_with(1323) self.assertEqual(22.05, params.sample_rate_ratio) self.assertEqual(audio, params.original_audio) self.assertEqual(441, params.samples_per_frame) self.assertEqual(1323, params.hanning_window_length) self.assertEqual([1, 2, 3, 4, 5], params.hanning_window_vals) self.assertEqual(441, params.rms_offset)
def test_calculate_local_cost(self): # standard voiced hypothesis calc: raptparam = raptparams.Raptparams() raptparam.lag_weight = 0.4 raptparam.minimum_allowed_freq = 50 max_corr_for_frame = 0.682 sample_rate = 44100 cost = pyrapt._calculate_local_cost((172, 0.5423), max_corr_for_frame, raptparam, sample_rate) self.assertEqual(0.5000018594104307, cost) # now test unvoiced hypothesis calc: raptparam.voicing_bias = 10.0 cost = pyrapt._calculate_local_cost((0, 0.0), max_corr_for_frame, raptparam, sample_rate) self.assertEqual(10.682, cost)
def test_run_nccf(self, mock_first_pass): with patch('pyrapt.pyrapt._second_pass_nccf') as mock_second_pass: mock_first_pass.return_value = [[(4, 0.6)] * 5] * 166 mock_second_pass.return_value = [[(4, 0.6)] * 3] * 166 downsampled_audio = (10, numpy.array([0, 1, 2, 3])) original_audio = (100, numpy.array([0, 1, 2, 3, 4, 5, 6])) params = raptparams.Raptparams() results = pyrapt._run_nccf(original_audio, params, downsampled_audio) mock_first_pass.assert_called_once_with(downsampled_audio, params) mock_second_pass.assert_called_once_with(original_audio, ANY, params) self.assertEqual(166, len(results)) self.assertEqual(4, results[0][0][0]) self.assertEqual(0.6, results[165][2][1])
def test_calculate_params_firstpass_only(self, mock_hanning): params = raptparams.Raptparams() params.is_two_pass_nccf = False params.frame_step_size = .008 self.assertEqual(None, params.original_audio) self.assertEqual(None, params.samples_per_frame) mock_hanning.return_value = [1, 2, 3, 4, 5] audio = (44199, [5.0] * 7000) pyrapt._calculate_params(params, audio) mock_hanning.assert_called_once_with(1326) self.assertEqual(None, params.sample_rate_ratio) self.assertEqual(audio, params.original_audio) self.assertEqual(354, params.samples_per_frame) self.assertEqual(1326, params.hanning_window_length) self.assertEqual([1, 2, 3, 4, 5], params.hanning_window_vals) self.assertEqual(530, params.rms_offset)
def test_get_second_pass_results_for_frame(self, mock_get_correlations): with patch('pyrapt.pyrapt._get_marked_results') as mock_res: mock_return_val = ([0.2] * 35, 0.5) mock_get_correlations.return_value = mock_return_val mock_res.return_value = [(4, 0.6), (4, 0.6), (4, 0.6)] * 165 audio = (44100, numpy.full(73612, 7.3)) i = 5 lag_range = 5 params = (raptparams.Raptparams(), nccfparams.Nccfparams()) params[0].sample_rate_ratio = 20 first_pass = [(4, 0.5), (5, 0.6), (22, 0.7)] * 165 frame_results = pyrapt._get_secondpass_frame_results( audio, i, lag_range, params, first_pass) mock_get_correlations.assert_called_once_with( audio, 5, first_pass, 5, params) mock_res.assert_called_once_with(mock_return_val, params, False) self.assertEqual(4, frame_results[0][0])
def test_calculate_cost_per_frame(self, mock_max_for_frame): mock_max_for_frame.return_value = 0.6772 raptparam = raptparams.Raptparams() raptparam = (44100, [2.0] * 73000) nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166 with patch('pyrapt.pyrapt._calculate_local_cost') as mock_local: with patch('pyrapt.pyrapt._get_best_cost') as mock_best: mock_local.return_value = 25 mock_best.return_value = 75 candidates = pyrapt._calculate_costs_per_frame(100, [], nccf_results, raptparam, 44100) self.assertEqual(2, len(candidates)) mock_max_for_frame.assert_called_once_with([(172, 0.5423), (770, 0.6772)]) mock_local.assert_called_with(ANY, 0.6772, raptparam, 44100) mock_best.assert_called_with(ANY, ANY, [], 100, raptparam)
def test_get_nccfparams(self): audio_input = (10, numpy.zeros(60)) params = raptparams.Raptparams() params.correlation_window_size = 2.0 params.minimum_allowed_freq = 2.0 params.maximum_allowed_freq = 2.0 params.frame_step_size = 2.0 first_params = pyrapt._get_nccf_params(audio_input, params, True) self.assertEqual(20, first_params.samples_correlated_per_lag) self.assertEqual(5, first_params.shortest_lag_per_frame) self.assertEqual(5, first_params.longest_lag_per_frame) self.assertEqual(20, first_params.samples_per_frame) self.assertEqual(2, first_params.max_frame_count) second_params = pyrapt._get_nccf_params(audio_input, params, False) self.assertEqual(0, second_params.shortest_lag_per_frame) self.assertEqual(5, second_params.longest_lag_per_frame) self.assertEqual(20, second_params.samples_correlated_per_lag) self.assertEqual(2, second_params.max_frame_count)
def test_get_correlations_for_input_lags(self, mock_get_correlation): mock_get_correlation.return_value = 0.6 audio = (44100, numpy.full(3500, 5.0)) params = (raptparams.Raptparams(), nccfparams.Nccfparams()) params[0].sample_rate_ratio = 4 params[1].samples_correlated_per_lag = 20 params[1].samples_per_frame = 100 params[1].shortest_lag_per_frame = 0 lag_range = 50 first_pass = [[(32, 0.7)]] * 35 results = pyrapt._get_correlations_for_input_lags( audio, 5, first_pass, lag_range, params) mock_get_correlation.assert_called_with(ANY, ANY, ANY, ANY, False) self.assertEqual(50, len(results[0])) self.assertEqual(0.6, results[0][32]) self.assertEqual(0.6, results[0][29]) self.assertEqual(0.6, results[0][35]) self.assertEqual(0.0, results[0][28]) self.assertEqual(0.0, results[0][36]) self.assertEqual(0.6, results[1])
def plot_example(audio_file, output_filename): params = raptparams.Raptparams() example_audio = pyrapt._get_audio_data(audio_file) samples_per_frame = int(example_audio[0] * params.frame_step_size) results = pyrapt.rapt_with_nccf(audio_file, transition_cost=0.5, doubling_cost=30.0) nccf_results = results[0] nccf_cands = [] z = [] iter = 1 for a in nccf_results: for b in a: if b[0] > 0.0: nccf_cands.append(float(example_audio[0]) / float(b[0])) z.append(iter * samples_per_frame) iter += 1 y = results[1] x = range(0, len(y)) y = numpy.array(y) x = numpy.array(x) x = x * samples_per_frame # spec = mlab.specgram(example_audio[1]) output_file(output_filename, title=audio_file) p = figure(title='example 0 w trans cost of 0.5 and doubling cost ' + 'of 30.0', x_axis_label='x', y_axis_label='y') if show_amp: p.line(range(0, len(example_audio[1])), example_audio[1], legend='amp of example.wav', line_width=1, line_color='orange') if show_freq: p.line(x, y, legend='example.wav f0', line_width=2, line_color='blue') if show_nccf: p.circle(z, nccf_cands, legend='nccf candidates', color='red', size=1) save(p)
def test_nccf_secondpass(self, mock_frame_results): mock_frame_results.return_value = [(5, 0.6), (30, 0.7), (55, 0.9)] first_pass = [(4, 0.6)] * 165 audio_data = (44100, numpy.full(73612, 6.8)) raptparam = raptparams.Raptparams() raptparam.sample_rate_ratio = 20 with patch('pyrapt.pyrapt._get_nccf_params') as mock_get_params: nccfparam = nccfparams.Nccfparams() # lag range is supposed to be 0-samplerate/50 for 2nd pass default: nccfparam.shortest_lag_per_frame = 0 nccfparam.longest_lag_per_frame = 882 nccfparam.max_frame_count = 165 params = (raptparam, nccfparam) mock_get_params.return_value = nccfparam candidates = pyrapt._second_pass_nccf(audio_data, first_pass, raptparam) mock_get_params.assert_called_once_with(audio_data, raptparam, False) # at each frame we get results, with lag range being max - 1 mock_frame_results.assert_called_with(audio_data, ANY, 881, params, first_pass) self.assertEqual(165, len(candidates)) self.assertEqual(5, candidates[0][0][0])
from pyrapt import pyrapt, raptparams from bokeh.plotting import figure, output_file, save import numpy # from matplotlib import mlab params = raptparams.Raptparams() example_audio = pyrapt._get_audio_data('example.wav') samples_per_frame = int(example_audio[0] * params.frame_step_size) y1 = pyrapt.rapt('example.wav') y2 = pyrapt.rapt('example.wav', doubling_cost=15.0) x = range(0, len(y1)) y1 = numpy.array(y1) y2 = numpy.array(y2) x = numpy.array(x) x = x * samples_per_frame # spec = mlab.specgram(example_audio[1]) output_file('visualization/output/example_plot.html', title='example.wav f0s') p = figure(title='vocal frequency', x_axis_label='x', y_axis_label='y') p.line(range(0, len(example_audio[1])), example_audio[1], legend='amp of example.wav', line_width=1, line_color='orange') p.line(x, y1, legend='example.wav f0 (basic)', line_width=2, line_color='blue') p.line(x, y2, legend='example.wav f0 (high doubling cost)', line_width=2, line_color='red') save(p)
def test_voiced_to_voiced(self): candidate = (709, 0.733) prev_entry = (0.373, (650, 0.841)) params = raptparams.Raptparams() cost = pyrapt._get_voiced_to_voiced_cost(candidate, prev_entry, params) self.assertEqual(0.39212528033835004, cost)