Feature/use py voice develop

Jenkinsfile

@@ -132,7 +132,7 @@ pipeline {
             sh "git clone --depth 1 --branch v2.5.2 [email protected]:ThrowTheSwitch/Unity.git"
             sh "git clone --depth 1 --branch v3.0.0 [email protected]:xmos-int/xtagctl.git"
             sh "git clone --depth 1 --branch develop [email protected]:xmos/audio_test_tools.git"
-            sh "git clone --depth 1 --branch main [email protected]:xmos/py_voice.git"
+            sh "git clone --depth 1 --branch feature/match_fwk_voice [email protected]:xmos/py_voice.git"
             sh "git clone --depth 1 --branch main [email protected]:xmos/amazon_wwe.git"
             sh "git clone --depth 1 --branch master [email protected]:xmos/sensory_sdk.git"
 

test/lib_ic/test_bad_state/test_bad_state.py

@@ -12,6 +12,7 @@
 
 import py_voice.test.ic.ic_test_helpers as ith
 from py_voice.config import config
+from py_voice.core import leq_smooth
 
 sys.path.append('../../shared/python/')
 import py_vs_c_utils as pvc
@@ -35,22 +36,22 @@
 speech_name = "007_podcast"
 speech_pos = 3
 
-exe_dir = '../../../../build/test/lib_ic/test_bad_state/bin/'
+exe_dir = '../../../build/test/lib_ic/test_bad_state/bin/'
 xe = os.path.join(exe_dir, 'fwk_voice_test_bad_state.xe')
 
 ap_config_file = Path(__file__).parents[2] / "shared" / "config" / "ic_conf_no_adapt_control.json"
 ap_conf = config.get_config_dict(ap_config_file)
 
-def run_xcore(conf_data, out_name):
-    conf_data.astype(np.int32).tofile('conf.bin')
+def run_xcore(conf_data, out_name, run_folder='.'):
+    conf_data.astype(np.int32).tofile(Path(run_folder, 'conf.bin'))
 
     with xtagctl.acquire("XCORE-AI-EXPLORER") as adapter_id:
-        xscope_fileio.run_on_target(adapter_id, xe)
+        xscope_fileio.run_on_target(adapter_id, xe, cwd=run_folder)
 
-    sr, out_data_int32 = wavfile.read('output.wav')
+    sr, out_data_int32 = wavfile.read(Path(run_folder, 'output.wav'))
     out_data = pvc.int32_to_float(out_data_int32)
-    os.rename('output.wav',out_name)
-    os.remove('conf.bin')
+    os.rename(Path(run_folder, 'output.wav'), out_name)
+    os.remove(Path(run_folder, 'conf.bin'))
     return sr, out_data
 
 def flatten_complex_array(comp_array):
@@ -100,7 +101,7 @@ def test_bad_state(room, speech_level, noise_name):
                                                                 noise_pos=noise_pos,
                                                                 speech_name=speech_name,
                                                                 speech_pos=speech_pos,
-                                                                speech_snr=speech_level,
+                                                                speech_level=speech_level,
                                                                 length_secs=length_secs)
     noise_ir = np.load(imp_path / imp_list[noise_spec[2]])
     speech_ir = np.load(imp_path / imp_list[speech_spec[2]])
@@ -115,33 +116,32 @@ def test_bad_state(room, speech_level, noise_name):
                                                 return_unsquashed=True, 
                                                 return_signals=True)
     src_path = os.path.abspath('src/')
-    prev_path = os.getcwd()
-    os.chdir(src_path)
-    wavfile.write('input.wav', fs, pvc.float_to_int32(mic_sig))
+
+    # os.chdir(src_path)
+    wavfile.write(Path(src_path, 'input.wav'), fs, pvc.float_to_int32(mic_sig.T))
 
     num_words_H = f_bin_count * 2 * phases # H_hat[ph][bin_count] for both real and complex
 
     # initialise IC to cancel the speech, do adapt
     conf_data_cancel_speech = form_conf_data(0, ideal_speech_cancellation_H, num_words_H)
-    sr, out_data_adapt_bad = run_xcore(conf_data_cancel_speech, 'output_bad_' + noise_name + '.wav')
+    sr, out_data_adapt_bad = run_xcore(conf_data_cancel_speech, 'output_bad_' + noise_name + '.wav', run_folder=src_path)
 
     # initialise IC to cancel the noise, don't adapt
     conf_data_cancel_noise = form_conf_data(2, ideal_noise_cancellation_H, num_words_H)
-    sr, out_data_fixed_good = run_xcore(conf_data_cancel_noise, 'output_good_' + noise_name + '.wav')
+    sr, out_data_fixed_good = run_xcore(conf_data_cancel_noise, 'output_good_' + noise_name + '.wav', run_folder=src_path)
 
-    os.rename('input.wav', 'input_' + noise_name + '.wav')
-    os.chdir(prev_path)
+    os.rename(Path(src_path, 'input.wav'), Path(src_path, 'input_' + noise_name + '.wav'))
 
-    t, adapt_bad = ith.leq_smooth(out_data_adapt_bad, fs, 0.05)
-    t, fixed_good = ith.leq_smooth(out_data_fixed_good, fs, 0.05)
+    t, adapt_bad = leq_smooth(out_data_adapt_bad, fs, 0.05)
+    t, fixed_good = leq_smooth(out_data_fixed_good, fs, 0.05)
 
     # check after 3 seconds we have converged to be better than the fixed good filter (because it should leak)
     average_fixed_good = np.mean(fixed_good[(t>3)*(t<5)])
     average_adapt_bad  = np.mean(adapt_bad[(t>3)*(t<5)])
     assert average_adapt_bad > average_fixed_good
 
     if __name__ == "__main__":
-        t2, original_speech = ith.leq_smooth(out_array[delay:, 0, 0], fs, 0.05)
+        t2, original_speech = leq_smooth(out_array[delay:, 0, 0], fs, 0.05)
         plt.plot(t, adapt_bad, label="adapt_bad")
         plt.plot(t, fixed_good, label="fixed_good")
         plt.plot(t2, original_speech, linestyle='--', label="raw_speech")

test/lib_ic/test_calc_vnr_pred/test_calc_vnr_pred.py

@@ -59,8 +59,8 @@ def test_calc_vnr_pred(target, show_plot=False):
 
         # Call Reference calc_vnr_pred()
         input_vnr_pred, output_vnr_pred = ifc.calc_vnr_pred(Error_ap)
-        ref_input_vnr_pred = np.append(ref_input_vnr_pred, input_vnr_pred[0])
-        ref_output_vnr_pred = np.append(ref_output_vnr_pred, output_vnr_pred[0])
+        ref_input_vnr_pred = np.append(ref_input_vnr_pred, ifc.input_vnr_pred[0])
+        ref_output_vnr_pred = np.append(ref_output_vnr_pred, ifc.output_vnr_pred[0])
 
     # Run DUT
     exe_name = xe

test/lib_vnr/test_vnr_cffi/test_vnr_cffi.py

@@ -6,7 +6,6 @@
 import os
 import pytest
 from pathlib import Path
-import py_voice.modules.vnr.frame_preprocessor as fp
 import py_voice.modules.vnr as vnr
 
 from build import vnr_test_py
@@ -34,16 +33,16 @@ def bfp_s32_to_float(bfp_struct, data):
 class vnr_feature_comparison:
     def __init__(self):
         self.vnr_obj = vnr.vnr(vnr_conf_path, model_file=vnr_model_path) 
-        self.x_data = np.zeros(fp.FRAME_LEN, dtype=np.float64)
+        self.x_data = np.zeros(vnr.FRAME_LEN, dtype=np.float64)
         err = vnr_test_lib.test_init()
 
     def process_frame(self, new_x_frame):
         frame_int = pvc.float_to_int32(new_x_frame)
 
         # Ref
-        self.x_data = np.roll(self.x_data, -fp.FRAME_ADVANCE, axis = 0)
-        self.x_data[fp.FRAME_LEN - fp.FRAME_ADVANCE:] = new_x_frame
-        X_spect = np.fft.rfft(self.x_data, fp.FRAME_LEN)
+        self.x_data = np.roll(self.x_data, -vnr.FRAME_ADVANCE, axis = 0)
+        self.x_data[vnr.FRAME_LEN - vnr.FRAME_ADVANCE:] = new_x_frame
+        X_spect = np.fft.rfft(self.x_data, vnr.FRAME_LEN)
         # Features
         ref_features = self.vnr_obj.extract_features(X_spect)
         # Inference
@@ -54,7 +53,7 @@ def process_frame(self, new_x_frame):
         dut_x_data = ffi.cast("int32_t *", ffi.from_buffer(frame_int[0].data))
         dut_features_bfp = np.zeros((20), dtype=np.int32)
         dut_features_bfp_ptr = ffi.cast("bfp_s32_t *", ffi.from_buffer(dut_features_bfp.data))
-        dut_features_data = np.zeros((fp.PATCH_WIDTH * fp.MEL_FILTERS), dtype=np.int32)
+        dut_features_data = np.zeros((vnr.PATCH_WIDTH * vnr.MEL_FILTERS), dtype=np.int32)
         dut_features_data_ptr = ffi.cast("int32_t *", ffi.from_buffer(dut_features_data.data))        
         # Features       
         vnr_test_lib.test_vnr_features(dut_features_bfp_ptr, dut_features_data_ptr, dut_x_data)
@@ -73,10 +72,10 @@ def test_frame_features(input_file):
     ref_ie_output = np.empty(0, dtype=np.float64)
     dut_ie_output = np.empty(0, dtype=np.float64)
 
-    for new_x_frame in sf.blocks(input_file, fp.FRAME_ADVANCE, always_2d=True):
+    for new_x_frame in sf.blocks(input_file, vnr.FRAME_ADVANCE, always_2d=True):
         # convert to [ch][samp]
         new_x_frame = new_x_frame.T
-        if len(new_x_frame[0]) < fp.FRAME_ADVANCE: continue
+        if len(new_x_frame[0]) < vnr.FRAME_ADVANCE: continue
 
         ref_features, dut_features, ref_ie, dut_ie = vnrc.process_frame(new_x_frame)
         ref_features_output = np.append(ref_features_output, ref_features)

test/lib_vnr/vnr_unit_tests/conftest.py

@@ -29,7 +29,7 @@ def _dequantise(output_data):
 
 @pytest.fixture
 def vnr_obj():
-    return vnr.vnr(vnr_conf, str(tflite_model))
+    return vnr.vnr(vnr_conf, model_file=str(tflite_model))
 
 @pytest.fixture
 def dut_runner(request, target):

test/lib_vnr/vnr_unit_tests/test_utils.py

@@ -1,9 +1,9 @@
 
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 from xmos_ai_tools.xinterpreters import TFLMHostInterpreter
 
-BATCH_SIZE = fp.PATCH_WIDTH * fp.MEL_FILTERS
+BATCH_SIZE = vnr.PATCH_WIDTH * vnr.MEL_FILTERS
 
 def rand_int32_arr(rng, size=None, hr_max=1, min=np.iinfo(np.int32).min, max=np.iinfo(np.int32).max+1):
     hr = rng.integers(hr_max)

test/lib_vnr/vnr_unit_tests/test_vnr_extract_features.py

@@ -1,11 +1,11 @@
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 import py_vs_c_utils as pvc
 from test_utils import rand_int32_arr, stft, BATCH_SIZE
 
 def test_vnr_extract_features(rng, quantise, vnr_obj, dut_runner):
 
-    input_words_per_frame = fp.FRAME_ADVANCE + 1 # No. of int32 values sent to dut as input per frame
+    input_words_per_frame = vnr.FRAME_ADVANCE + 1 # No. of int32 values sent to dut as input per frame
 
     norm_patch_output_len = BATCH_SIZE + 1 # + 1 for exponent
     quant_patch_output_len = BATCH_SIZE / 4 # / 4 because the output is int8 but we read in words
@@ -17,18 +17,18 @@ def test_vnr_extract_features(rng, quantise, vnr_obj, dut_runner):
     test_frames = 1024
     ref_normalised_output = np.empty(0, dtype=np.float64)
 
-    x_data = np.zeros(fp.FRAME_LEN, dtype=np.float64)    
+    x_data = np.zeros(vnr.FRAME_LEN, dtype=np.float64)    
     for _ in range(test_frames):
         enable_highpass = rng.integers(2)
 
-        data = rand_int32_arr(rng, fp.FRAME_ADVANCE, 8)
+        data = rand_int32_arr(rng, vnr.FRAME_ADVANCE, 8)
 
         input_data = np.append(input_data, data)
         input_data = np.append(input_data, enable_highpass)
 
         # Ref form input frame implementation
         new_x_frame = pvc.int32_to_double(data, -31)
-        X_spect, x_data = stft(x_data, new_x_frame, fp.FRAME_LEN, fp.FRAME_ADVANCE, fp.NFFT)
+        X_spect, x_data = stft(x_data, new_x_frame, vnr.FRAME_LEN, vnr.FRAME_ADVANCE, vnr.NFFT)
         normalised_patch = vnr_obj.extract_features(X_spect, hp=enable_highpass)
         ref_normalised_output = np.append(ref_normalised_output, normalised_patch)
 

test/lib_vnr/vnr_unit_tests/test_vnr_form_input_frame.py

@@ -1,28 +1,28 @@
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 import py_vs_c_utils as pvc
 from test_utils import rand_int32_arr, stft
 
 def test_vnr_form_input_frame(rng, dut_runner):
-    input_words_per_frame = fp.FRAME_ADVANCE #No. of int32 values sent to dut as input per frame
+    input_words_per_frame = vnr.FRAME_ADVANCE #No. of int32 values sent to dut as input per frame
 
-    fd_frame_len = int(fp.NFFT//2 + 1)
+    fd_frame_len = int(vnr.NFFT//2 + 1)
     output_words_per_frame = fd_frame_len*2 + 1 # No. of int32 output values expected from dut per frame (257 complex data values and 1 exponent)
 
     input_data = np.array([input_words_per_frame, output_words_per_frame], dtype=np.int32)
 
     test_frames = 2048
 
-    x_data = np.zeros(fp.FRAME_LEN, dtype=np.float64)    
+    x_data = np.zeros(vnr.FRAME_LEN, dtype=np.float64)    
     ref_output = np.empty(0, dtype=np.complex128)
     for _ in range(test_frames):
         # Generate input data
-        data = rand_int32_arr(rng, fp.FRAME_ADVANCE, 8)
+        data = rand_int32_arr(rng, vnr.FRAME_ADVANCE, 8)
         input_data = np.append(input_data, data)
 
         # Ref form input frame implementation
         new_x_frame = pvc.int32_to_double(data, -31)
-        X_spect, x_data = stft(x_data, new_x_frame, fp.FRAME_LEN, fp.FRAME_ADVANCE, fp.NFFT)
+        X_spect, x_data = stft(x_data, new_x_frame, vnr.FRAME_LEN, vnr.FRAME_ADVANCE, vnr.NFFT)
         ref_output = np.append(ref_output, X_spect).astype(np.complex128)
 
     op = dut_runner(input_data) # dut data has exponent followed by 257*2 data values

test/lib_vnr/vnr_unit_tests/test_vnr_full.py

@@ -1,30 +1,30 @@
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 import py_vs_c_utils as pvc
 from test_utils import rand_int32_arr, stft
 
 def test_vnr_full(rng, vnr_obj, dut_runner):
 
-    input_words_per_frame = fp.FRAME_ADVANCE + 1#No. of int32 values sent to dut as input per frame
+    input_words_per_frame = vnr.FRAME_ADVANCE + 1#No. of int32 values sent to dut as input per frame
     output_words_per_frame = 2
 
     input_data = np.array([input_words_per_frame, output_words_per_frame], dtype=np.int32)
 
     test_frames = 2048
     ref_output_double = np.empty(0, dtype=np.float64)
 
-    x_data = np.zeros(fp.FRAME_LEN, dtype=np.float64)    
+    x_data = np.zeros(vnr.FRAME_LEN, dtype=np.float64)    
 
     for _ in range(test_frames):
         enable_highpass = rng.integers(2)
         # Generate input data
-        data = rand_int32_arr(rng, fp.FRAME_ADVANCE, 8)
+        data = rand_int32_arr(rng, vnr.FRAME_ADVANCE, 8)
         input_data = np.append(input_data, data)
         input_data = np.append(input_data, enable_highpass)
 
         # Ref VNR implementation
         new_x_frame = pvc.int32_to_double(data, -31)
-        X_spect, x_data = stft(x_data, new_x_frame, fp.FRAME_LEN, fp.FRAME_ADVANCE, fp.NFFT)
+        X_spect, x_data = stft(x_data, new_x_frame, vnr.FRAME_LEN, vnr.FRAME_ADVANCE, vnr.NFFT)
         this_patch = vnr_obj.extract_features(X_spect, hp=enable_highpass)
         ref_output_double = np.append(ref_output_double, vnr_obj.run(this_patch))
 

test/lib_vnr/vnr_unit_tests/test_vnr_inference.py

@@ -1,5 +1,5 @@
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 import py_vs_c_utils as pvc
 from test_utils import rand_int32_arr, BATCH_SIZE
 
@@ -20,7 +20,7 @@ def test_vnr_inference(rng, vnr_obj, dut_runner):
 
         # Ref implementation
         this_patch = pvc.int32_to_double(data, exp)
-        this_patch = this_patch.reshape(1, 1, fp.PATCH_WIDTH, fp.MEL_FILTERS)
+        this_patch = this_patch.reshape(1, 1, vnr.PATCH_WIDTH, vnr.MEL_FILTERS)
         ref_output_double = np.append(ref_output_double, vnr_obj.run(this_patch))
 
     op = dut_runner(input_data)

test/lib_vnr/vnr_unit_tests/test_vnr_priv_log2.py

@@ -1,26 +1,26 @@
 
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 import py_vs_c_utils as pvc
 from test_utils import rand_int32_arr
 
 def test_vnr_priv_log2(rng, dut_runner):
 
     # No. of int32 values sent to dut as input per frame
-    input_words_per_frame = fp.MEL_FILTERS*2 # MEL_FILTERS float_s32_t values 
+    input_words_per_frame = vnr.MEL_FILTERS*2 # MEL_FILTERS float_s32_t values 
 
     # No. of int32 output values expected from dut per frame
-    output_words_per_frame = fp.MEL_FILTERS # MEL_FILTERS uq8_24 values. Exponent fixed to -24
+    output_words_per_frame = vnr.MEL_FILTERS # MEL_FILTERS uq8_24 values. Exponent fixed to -24
 
     input_data = np.array([input_words_per_frame, output_words_per_frame], dtype=np.int32)
     test_frames = 2048
 
     ref_output_float = np.empty(0, dtype=np.float64)
 
     for _ in range(test_frames):
-        data = np.zeros(fp.MEL_FILTERS*2, dtype=np.int32)
-        data[0::2] = rand_int32_arr(rng, fp.MEL_FILTERS, 5, min=1)
-        data[1::2] = rand_int32_arr(rng, fp.MEL_FILTERS, min=-32, max=16) # exp
+        data = np.zeros(vnr.MEL_FILTERS*2, dtype=np.int32)
+        data[0::2] = rand_int32_arr(rng, vnr.MEL_FILTERS, 5, min=1)
+        data[1::2] = rand_int32_arr(rng, vnr.MEL_FILTERS, min=-32, max=16) # exp
         data = np.array(data, dtype=np.int32)
         input_data = np.append(input_data, data)
 

test/lib_vnr/vnr_unit_tests/test_vnr_priv_make_slice.py

@@ -1,30 +1,30 @@
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 import py_vs_c_utils as pvc
 from test_utils import rand_int32_arr, stft
 
 def test_vnr_priv_make_slice(rng, vnr_obj, dut_runner):
 
-    input_words_per_frame = fp.FRAME_ADVANCE + 1 #No. of int32 values sent to dut as input per frame
-    output_words_per_frame = fp.MEL_FILTERS # MEL_FILTERS uq8_24 values. Exponent fixed to -24
+    input_words_per_frame = vnr.FRAME_ADVANCE + 1 #No. of int32 values sent to dut as input per frame
+    output_words_per_frame = vnr.MEL_FILTERS # MEL_FILTERS uq8_24 values. Exponent fixed to -24
 
     input_data = np.array([input_words_per_frame, output_words_per_frame], dtype=np.int32)    
 
     test_frames = 2048
 
-    x_data = np.zeros(fp.FRAME_LEN, dtype=np.float64)    
+    x_data = np.zeros(vnr.FRAME_LEN, dtype=np.float64)    
     ref_output_float = np.empty(0, dtype=np.float64)
 
     for _ in range(test_frames):
         enable_highpass = rng.integers(2)
         # Generate input data
-        data = rand_int32_arr(rng, fp.FRAME_ADVANCE, 8)
+        data = rand_int32_arr(rng, vnr.FRAME_ADVANCE, 8)
         input_data = np.append(input_data, data)
         input_data = np.append(input_data, enable_highpass)
 
         # Ref form input frame implementation
         new_x_frame = pvc.int32_to_double(data, -31)
-        X_spect, x_data = stft(x_data, new_x_frame, fp.FRAME_LEN, fp.FRAME_ADVANCE, fp.NFFT)
+        X_spect, x_data = stft(x_data, new_x_frame, vnr.FRAME_LEN, vnr.FRAME_ADVANCE, vnr.NFFT)
         new_slice = vnr_obj.make_slice(X_spect, enable_highpass)
 
         ref_output_float = np.append(ref_output_float, new_slice)

test/lib_vnr/vnr_unit_tests/test_vnr_priv_mel_compute.py

@@ -1,17 +1,17 @@
 
 import numpy as np
-import py_voice.modules.vnr.frame_preprocessor as fp
+import py_voice.modules.vnr as vnr
 import py_vs_c_utils as pvc
 from test_utils import rand_int32_arr
 
 def test_vnr_priv_mel_compute(rng, vnr_obj, dut_runner):
 
-    fd_frame_len = int(fp.NFFT/2 + 1)
+    fd_frame_len = int(vnr.NFFT/2 + 1)
     # No. of int32 values sent to dut as input per frame
     input_words_per_frame = fd_frame_len*2 + 1 #fd_frame_len complex values and 1 exponent per frame
 
     # No. of int32 output values expected from dut per frame (257 complex data values and 1 exponent)
-    output_words_per_frame = fp.MEL_FILTERS*2 #float_s32_t y[MEL_FILTERS]
+    output_words_per_frame = vnr.MEL_FILTERS*2 #float_s32_t y[MEL_FILTERS]
 
     input_data = np.array([input_words_per_frame, output_words_per_frame], dtype=np.int32)