def test_duet_outputs(self):
input_file_name = os.path.join('..', 'input',
'dev1_female3_inst_mix.wav')
signal = nussl.AudioSignal(path_to_input_file=input_file_name)
refact_duet = nussl.Duet(signal, num_sources=3)
refact_duet_result = refact_duet.run()
duet = nussl.Duet(signal, 3)
nussl_duet_result = duet.run()
assert refact_duet_result == nussl_duet_result
def test_convert_peaks(self):
duet = nussl.Duet(self.signal, 3)
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
duet.attenuation_bins = self.benchmark_dict['benchmark_atn_bins']
duet.delay_bins = self.benchmark_dict['benchmark_delay_bins']
duet.peak_indices = self.benchmark_dict['benchmark_peak_indices']
delay_peak_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_delay_peak.npy')
atn_peak_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_atn_peak.npy')
atn_delay_est_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_atn_delay_est.npy')
benchmark_delay_peak = np.load(delay_peak_path)
benchmark_atn_peak = np.load(atn_peak_path)
benchmark_atn_delay_est = np.load(atn_delay_est_path)
delay_peak, atn_delay_est, atn_peak = duet._convert_peaks()
assert np.all(benchmark_delay_peak == delay_peak)
assert np.all(benchmark_atn_delay_est == atn_delay_est)
assert np.all(benchmark_atn_peak == atn_peak)
def test_convert_peaks(self):
duet = nussl.Duet(self.signal, 3)
# Set these matrices as KNOWN ground truth values up til this point
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
duet.attenuation_bins = self.benchmark_dict['benchmark_atn_bins']
duet.delay_bins = self.benchmark_dict['benchmark_delay_bins']
duet.peak_indices = self.benchmark_dict['benchmark_peak_indices']
# Test against these matrices
benchmark_delay_peak = self.benchmark_dict['benchmark_delay_peak']
benchmark_atn_peak = self.benchmark_dict['benchmark_atn_peak']
benchmark_atn_delay_est = self.benchmark_dict[
'benchmark_atn_delay_est']
# This is the calculation we are testing against
delay_peak, atn_delay_est, atn_peak = duet._convert_peaks(
duet.peak_indices)
assert np.all(benchmark_delay_peak == delay_peak)
assert np.all(benchmark_atn_delay_est == atn_delay_est)
assert np.all(benchmark_atn_peak == atn_peak)
def test_make_histogram(self):
# Use the same stfts for comparing this function's outputs
duet = nussl.Duet(self.signal, 3)
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
# Load benchmarks
hist_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_hist.npy')
atn_bins_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_atn_bins.npy')
delay_bins_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_delay_bins.npy')
benchmark_hist = np.load(hist_path)
benchmark_atn_bins = np.load(atn_bins_path)
benchmark_delay_bins = np.load(delay_bins_path)
hist, atn_bins, delay_bins = duet._make_histogram()
assert np.allclose(benchmark_hist, hist)
assert np.all(benchmark_atn_bins == atn_bins)
assert np.all(benchmark_delay_bins == delay_bins)
def test_make_audio_signals(self):
duet = nussl.Duet(self.signal, 3)
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
duet.atn_bins = self.benchmark_dict['benchmark_atn_bins']
duet.delay_bins = self.benchmark_dict['benchmark_delay_bins']
duet.peak_indices = self.benchmark_dict['benchmark_peak_indices']
duet.delay_peak = self.benchmark_dict['benchmark_delay_peak']
duet.atn_peak = self.benchmark_dict['benchmark_atn_peak']
duet.result_masks = self.benchmark_dict['benchmark_masks']
final_signals_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_final_signals.npy')
benchmark_final_signals = np.load(final_signals_path)
final_signals = duet.make_audio_signals()
# Is the audio data the same?
assert all(
np.array_equal(benchmark_final_signals[i].audio_data,
final_signals[i].audio_data)
for i in range(len(final_signals)))
# Check to see if AudioSignal's API changed; do we need to refreeze?
assert all(benchmark_final_signals[i] == final_signals[i]
for i in range(len(final_signals)))
assert np.all(benchmark_final_signals == final_signals)
def main():
# Load input file
input_file_name = os.path.join('..', 'Input', 'dev1_female3_inst_mix.wav')
signal = nussl.AudioSignal(path_to_input_file=input_file_name)
# make a directory to store output if needed
if not os.path.exists(os.path.join('..', 'Output/')):
os.mkdir(os.path.join('..', 'Output/'))
nussl.USE_LIBROSA_STFT = False
# Set up DUET
duet = nussl.Duet(signal, num_sources=3)
# and run
duet.run()
# plot histogram results
duet.plot(os.path.join('..', 'Output', 'duet_2d.png'))
duet.plot(os.path.join('..', 'Output', 'duet_3d.png'), three_d_plot=True)
# Create output file for each source found
output_name_stem = os.path.join('..', 'Output', 'duet_source')
i = 1
for s in duet.make_audio_signals():
output_file_name = output_name_stem + str(i) + '.wav'
s.write_audio_to_file(output_file_name)
i += 1
def test_duet_final_outputs(self):
# Test final outputs
benchmark_mask = self.benchmark_dict['benchmark_masks']
duet = nussl.Duet(self.signal, 3)
duet_masks = duet.run()
for i in range(len(duet_masks)):
assert np.array_equal(benchmark_mask[i].mask, duet_masks[i].mask)
def test_compute_spectrogram_1_channel(self):
# Test with one channel, should throw value error
num_samples = 100 # 1 second
np_sin = np.sin(np.linspace(0, 100 * 2 * np.pi,
num_samples)) # Freq = 100 Hz
signal = nussl.AudioSignal(audio_data_array=np_sin)
with self.assertRaises(ValueError):
duet = nussl.Duet(signal, 3)
duet._compute_spectrogram(duet.sample_rate)
def freeze_duet_values():
"""
Freezes essential values from DUET in its current implementation for benchmarking
See test_benchmark_duet() in test_duet.py for usage
"""
signal = nussl.AudioSignal(
nussl.efz_utils.download_audio_file('dev1_female3_inst_mix.wav'))
duet = nussl.Duet(signal, 3)
output_folder = os.path.abspath('duet_benchmarks')
if not os.path.isdir(output_folder):
os.mkdir(output_folder)
duet.stft_ch0, duet.stft_ch1, \
duet.frequency_matrix = duet._compute_spectrogram(duet.sample_rate)
np.save(os.path.join(output_folder, 'benchmark_stft_ch0'), duet.stft_ch0)
np.save(os.path.join(output_folder, 'benchmark_stft_ch1'), duet.stft_ch1)
np.save(os.path.join(output_folder, 'benchmark_wmat'),
duet.frequency_matrix)
duet.symmetric_atn, duet.delay = duet._compute_atn_delay(
duet.stft_ch0, duet.stft_ch1, duet.frequency_matrix)
np.save(os.path.join(output_folder, 'benchmark_sym_atn'),
duet.symmetric_atn)
np.save(os.path.join(output_folder, 'benchmark_delay'), duet.delay)
duet.normalized_attenuation_delay_histogram, \
duet.attenuation_bins, duet.delay_bins = duet._make_histogram()
np.save(os.path.join(output_folder, 'benchmark_hist'),
duet.normalized_attenuation_delay_histogram)
np.save(os.path.join(output_folder, 'benchmark_atn_bins'),
duet.attenuation_bins)
np.save(os.path.join(output_folder, 'benchmark_delay_bins'),
duet.delay_bins)
duet.peak_indices = nussl.utils.find_peak_indices(
duet.normalized_attenuation_delay_histogram,
duet.num_sources,
threshold=duet.peak_threshold,
min_dist=[duet.attenuation_min_distance, duet.delay_min_distance])
np.save(os.path.join(output_folder, 'benchmark_peak_indices'),
duet.peak_indices)
duet.delay_peak, duet.atn_delay_est, duet.atn_peak = duet._convert_peaks(
duet.peak_indices)
np.save(os.path.join(output_folder, 'benchmark_delay_peak'),
duet.delay_peak)
np.save(os.path.join(output_folder, 'benchmark_atn_delay_est'),
duet.atn_delay_est)
np.save(os.path.join(output_folder, 'benchmark_atn_peak'), duet.atn_peak)
duet.masks = duet._compute_masks()
np.save(os.path.join(output_folder, 'benchmark_masks'), duet.masks)
final_signals = duet.make_audio_signals()
np.save(os.path.join(output_folder, 'benchmark_final_signals'),
final_signals)
def test_duet_final_outputs(self):
# Test final outputs
mask_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_masks.npy')
benchmark_mask = np.load(mask_path)
duet = nussl.Duet(self.signal, 3)
duet_masks = duet.run()
for i in range(len(duet_masks)):
assert np.array_equal(benchmark_mask[i].mask, duet_masks[i].mask)
def test_duet(self):
path = os.path.join('..', 'Input', 'dev1_female3_inst_mix.wav')
a = nussl.AudioSignal(path)
d = nussl.Duet(a, 3)
d()
j = d.to_json()
e = nussl.Duet.from_json(j)
worked = d == e
return worked
def test_multiple_duet(self):
benchmark_mask = self.benchmark_dict['benchmark_masks']
duet = nussl.Duet(self.signal, 3)
duet.run()
duet.audio_signal = nussl.AudioSignal(self.dev1_wdrums)
duet.run()
duet.audio_signal = nussl.AudioSignal(self.dev1_female3)
duet_masks = duet.run()
for i in range(len(duet_masks)):
assert np.array_equal(benchmark_mask[i].mask, duet_masks[i].mask)
def test_compute_spectrogram_wmat(self):
# Load Duet values to benchmark against
duet = nussl.Duet(self.signal, 3)
duet_sft0, duet_sft1, duet_wmat = duet._compute_spectrogram(
duet.sample_rate)
assert np.allclose(self.benchmark_dict['benchmark_stft_ch0'],
duet_sft0)
assert np.allclose(self.benchmark_dict['benchmark_stft_ch1'],
duet_sft1)
assert np.allclose(self.benchmark_dict['benchmark_wmat'], duet_wmat)
def test_compute_atn_delay(self):
# Use the same stfts for comparing the two functions' outputs
duet = nussl.Duet(self.signal, 3)
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
symmetric_atn, delay = duet._compute_atn_delay(duet.stft_ch0,
duet.stft_ch1,
duet.frequency_matrix)
assert np.allclose(self.benchmark_dict['benchmark_sym_atn'],
symmetric_atn)
assert np.allclose(self.benchmark_dict['benchmark_delay'], delay)
def freeze_duet_values():
signal = nussl.AudioSignal(
os.path.join('..', 'input', 'dev1_female3_inst_mix.wav'))
duet = nussl.Duet(signal, 3)
output_folder = os.path.abspath('duet_reference/duet_benchmarks')
duet.stft_ch0, duet.stft_ch1, duet.frequency_matrix = duet._compute_spectrogram(
duet.sample_rate)
np.save(os.path.join(output_folder, "benchmark_stft_ch0"), duet.stft_ch0)
np.save(os.path.join(output_folder, "benchmark_stft_ch1"), duet.stft_ch1)
np.save(os.path.join(output_folder, "benchmark_wmat"),
duet.frequency_matrix)
duet.symmetric_atn, duet.delay = duet._compute_atn_delay(
duet.stft_ch0, duet.stft_ch1, duet.frequency_matrix)
np.save(os.path.join(output_folder, "benchmark_sym_atn"),
duet.symmetric_atn)
np.save(os.path.join(output_folder, "benchmark_delay"), duet.delay)
duet.normalized_attenuation_delay_histogram, duet.attenuation_bins, duet.delay_bins = duet._make_histogram(
)
np.save(os.path.join(output_folder, "benchmark_hist"),
duet.normalized_attenuation_delay_histogram)
np.save(os.path.join(output_folder, "benchmark_atn_bins"),
duet.attenuation_bins)
np.save(os.path.join(output_folder, "benchmark_delay_bins"),
duet.delay_bins)
duet.peak_indices = nussl.utils.find_peak_indices(
duet.normalized_attenuation_delay_histogram,
duet.num_sources,
threshold=duet.peak_threshold,
min_dist=[duet.attenuation_min_distance, duet.delay_min_distance])
np.save(os.path.join(output_folder, "benchmark_peak_indices"),
duet.peak_indices)
duet.delay_peak, duet.atn_delay_est, duet.atn_peak = duet._convert_peaks()
np.save(os.path.join(output_folder, "benchmark_delay_peak"),
duet.delay_peak)
np.save(os.path.join(output_folder, "benchmark_atn_delay_est"),
duet.atn_delay_est)
np.save(os.path.join(output_folder, "benchmark_atn_peak"), duet.atn_peak)
duet.masks = duet._compute_masks()
np.save(os.path.join(output_folder, "benchmark_masks"), duet.masks)
final_signals = duet.make_audio_signals()
np.save(os.path.join(output_folder, "benchmark_final_signals"),
final_signals)
def test_multiple_duet(self):
mask_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_masks.npy')
benchmark_mask = np.load(mask_path)
duet = nussl.Duet(self.signal, 3)
duet_masks = duet.run()
path_to_benchmark_file = os.path.join('..', 'Input',
'dev1_wdrums_inst_mix.wav')
duet.audio_signal = nussl.AudioSignal(path_to_benchmark_file)
duet_masks = duet.run()
path_to_benchmark_file = os.path.join('..', 'Input',
'dev1_female3_inst_mix.wav')
duet.audio_signal = nussl.AudioSignal(path_to_benchmark_file)
duet_masks = duet.run()
for i in range(len(duet_masks)):
assert np.array_equal(benchmark_mask[i].mask, duet_masks[i].mask)
def test_compute_masks(self):
duet = nussl.Duet(self.signal, 3)
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
duet.attenuation_bins = self.benchmark_dict['benchmark_atn_bins']
duet.delay_bins = self.benchmark_dict['benchmark_delay_bins']
duet.peak_indices = self.benchmark_dict['benchmark_peak_indices']
duet.delay_peak = self.benchmark_dict['benchmark_delay_peak']
duet.atn_peak = self.benchmark_dict['benchmark_atn_peak']
mask_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_masks.npy')
benchmark_mask = np.load(mask_path)
masks = duet._compute_masks()
for i in range(len(masks)):
assert np.array_equal(benchmark_mask[i].mask, masks[i].mask)
def test_compute_spectrogram_wmat(self):
# Load MATLAB values
# f_mat_path = os.path.join('duet_reference', 'rickard_duet', 'fmat')
tf1_path = os.path.join('duet_reference', 'rickard_duet', 'tf1')
tf2_path = os.path.join('duet_reference', 'rickard_duet', 'tf2')
# fmat = scipy.io.loadmat(f_mat_path)['fmat']
tf1_mat = scipy.io.loadmat(tf1_path)['tf1']
tf2_mat = scipy.io.loadmat(tf2_path)['tf2']
path = os.path.join('..', 'Input', 'dev1_female3_inst_mix.wav')
signal = nussl.AudioSignal(path)
duet = nussl.Duet(signal, 3)
duet.stft_params.window_length = 1024
duet.stft_params.window_type = nussl.WINDOW_RECTANGULAR
duet.stft_params.hop_length = duet.stft_params.window_length
duet_sft0, duet_sft1, duet_wmat = duet._compute_spectrogram(
duet.sample_rate)
assert np.allclose(duet_sft0, tf1_mat, atol=1e-06)
assert np.allclose(duet_sft1, tf2_mat, atol=1e-06)
def test_peak_indices(self):
duet = nussl.Duet(self.signal, 3)
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
hist_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_hist.npy')
peak_indices_path = os.path.join('duet_reference', 'duet_benchmarks',
'benchmark_peak_indices.npy')
benchmark_hist = np.load(hist_path)
benchmark_peak_indices = np.load(peak_indices_path)
duet_peak_indices = nussl.utils.find_peak_indices(
benchmark_hist,
duet.num_sources,
threshold=duet.peak_threshold,
min_dist=[duet.attenuation_min_distance, duet.delay_min_distance])
assert np.all(benchmark_peak_indices == duet_peak_indices)
def test_peak_indices(self):
duet = nussl.Duet(self.signal, 3)
# Set these matrices as KNOWN ground truth values up til this point
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
# Test against these matrices
benchmark_hist = self.benchmark_dict['benchmark_hist']
benchmark_peak_indices = self.benchmark_dict['benchmark_peak_indices']
# This is the calculation we are testing against
duet_peak_indices = nussl.utils.find_peak_indices(
benchmark_hist,
duet.num_sources,
threshold=duet.peak_threshold,
min_dist=[duet.attenuation_min_distance, duet.delay_min_distance])
assert np.all(benchmark_peak_indices == duet_peak_indices)
def test_compute_masks(self):
duet = nussl.Duet(self.signal, 3)
# Set these matrices as KNOWN ground truth values up til this point
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
duet.attenuation_bins = self.benchmark_dict['benchmark_atn_bins']
duet.delay_bins = self.benchmark_dict['benchmark_delay_bins']
duet.peak_indices = self.benchmark_dict['benchmark_peak_indices']
duet.delay_peak = self.benchmark_dict['benchmark_delay_peak']
duet.atn_peak = self.benchmark_dict['benchmark_atn_peak']
# Test against these matrices
benchmark_masks = self.benchmark_dict['benchmark_masks']
# This is the calculation we are testing against
masks = duet._compute_masks()
for i in range(len(masks)):
assert np.array_equal(benchmark_masks[i].mask, masks[i].mask)
def test_make_histogram(self):
# Use the same stfts for comparing this function's outputs
duet = nussl.Duet(self.signal, 3)
# Set these matrices as KNOWN ground truth values up til this point
duet.stft_ch0 = self.benchmark_dict['benchmark_stft_ch0']
duet.stft_ch1 = self.benchmark_dict['benchmark_stft_ch1']
duet.frequency_matrix = self.benchmark_dict['benchmark_wmat']
duet.symmetric_atn = self.benchmark_dict['benchmark_sym_atn']
duet.delay = self.benchmark_dict['benchmark_delay']
# Test against these matrices
benchmark_hist = self.benchmark_dict['benchmark_hist']
benchmark_atn_bins = self.benchmark_dict['benchmark_atn_bins']
benchmark_delay_bins = self.benchmark_dict['benchmark_delay_bins']
# This is the calculation we are testing against
hist, atn_bins, delay_bins = duet._make_histogram()
assert np.allclose(benchmark_hist, hist)
assert np.all(benchmark_atn_bins == atn_bins)
assert np.all(benchmark_delay_bins == delay_bins)
