def run(mic_observation_path, OUT_wav_path): data, rate = read_mic_wav_from_folder(mic_observation_path, max_len_sec=45) stft_arr = mic_stft.stft_arr(x_arr=data, fftsize=512) sensor_positions = mic_geometry.get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = mic_geometry.get_source_position(0, 0) steering_vector = mic_steering.propagation_vector_free_field( sensor_positions, source_position, N_fft=512, F_s=rate).transpose(1, 0) S_spec = gsc_griffiths_filter(stft_arr=stft_arr, d_arr=steering_vector, mic_pos='closed') # ISFFT signal sig_out = istft(S_spec.transpose(1, 0), overlap=2) # ISFFT signal sf.write(OUT_wav_path, sig_out, rate)
def run_once(): # ################################################################# # # 1.0 - _wav_wbn45_dict0 PROFILE # # vert_mic_count = 6 # hor_mic_count = 11 # dHor = 0.035 # dVert = 0.05 # max_len_sec = 45 # n_fft = 512 # # (angle_hor_log, angle_vert_log) = (0.0, 0.0) # (angle_inf_hor_log, angle_inf_vert_log) = (45, 0) # # angle_h = -angle_hor_log # angle_v = -angle_vert_log # # angle_inf_h = -angle_inf_hor_log # angle_inf_v = -angle_inf_vert_log # # angle_h = -angle_hor_log # angle_v = -angle_vert_log # # _mix_start = 0.0 # _mix_end = 20.0 # # in_wav_path = r'./data/_wav_wbn45_dict0/' # out_wav_path = r'./data/out/' # ################################################################# # ################################################################# # 1.0 - _sol PROFILE MVDR vert_mic_count = 6 hor_mic_count = 11 dHor = 0.035 dVert = 0.05 max_len_sec = 3 * 60 n_fft = 512 (angle_hor_log, angle_vert_log) = (13.8845, 6.60824) (angle_inf_hor_log, angle_inf_vert_log) = (-15.06, -0.31) angle_h = -angle_hor_log angle_v = -angle_vert_log angle_inf_h = -angle_inf_hor_log angle_inf_v = -angle_inf_vert_log in_wav_path = r'./data/_sol/' out_wav_path = r'./data/out/' _mix_start = 28 _mix_end = 48 ################################################################# ################################################################# # 1.0 - Read signal x_all_arr, sr = read_mic_wav_from_folder(in_wav_path, vert_mic_count, hor_mic_count, max_len_sec=max_len_sec) x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] (n_channels, n_samples) = x_all_arr.shape print("Array data read done!") print(" n_channels = ", n_channels) print(" n_samples = ", n_samples) print(" freq = ", sr) ################################################################# # 2 - Do STFT stft_all = stft_arr(x_all_arr, fftsize=n_fft) (n_bins, n_sensors, n_frames) = stft_all.shape print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" n_frames = ", n_frames) ################################################################# # 3 - Calc steering vector print('Calc steering vector!') print(' (angle_h, angle_v) = ', angle_h, angle_v) print(' (angle_inf_h, angle_inf_v) = ', angle_inf_h, angle_inf_v) sensor_positions = get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = get_source_position(angle_h, angle_v, radius=6.0) source_position_inf = get_source_position(angle_inf_h, angle_inf_v, radius=6.0) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) d_arr_inf = propagation_vector_free_field(sensor_positions, source_position_inf, N_fft=n_fft, F_s=sr) ################################################################# # 4 - Calc DS beamforming in desired and noise direction result_spec = ds_beamforming(stft_all, d_arr.T) result_spec_inf = ds_beamforming(stft_all, d_arr_inf.T) ################################################################# # 5 - ISTFT sig_sp = istft(result_spec.transpose((1, 0)), overlap=2) sig_inf = istft(result_spec_inf.transpose((1, 0)), overlap=2) sf.write(r"out/out_ds_sp.wav", sig_sp, sr) sf.write(r"out/out_ds_inf.wav", sig_inf, sr) ################################################################# # 4 - NULL filter output result_spec, _ = null_filter(stft_all, d_arr_sp=d_arr.T, d_arr_inf=d_arr_inf.T) sig_out = istft(result_spec.transpose((1, 0)), overlap=2) sf.write(r"out/out_null.wav", sig_out, sr) #result_spec, _ = null_filter_ex(stft_mix_arr, d_arr_sp=d_arr.T, lst_d_arr_inf=[d_arr_inf.T, d_arr_inf_d1.T, d_arr_inf_d2.T]) # ################################################################# # # 6 - AP filter # M = 200 # step = 0.05 # L = 5 # sig_result = affine_projection_filter(main=sig_sp, ref=sig_inf, M=M,step=step,L=5) ################################################################# # 6.1 - AP filter + cyclic parameters # M = 200 # step = 0.05 # L = 5 # leak = 0.0 # delay = -5 #params = [(200, 0.005, 5), (200, 0.05, 5), (200, 0.1, 5), (200, 0.5, 5)] #params = [(200, 0.005, 5),(200, 0.005, 11), (200, 0.005, 25) , (200, 0.005, 35)] params = [(100, 0.01, 5, 0.01, -5)] for (M, step, L, leak, delay) in params: print("process M = {}, step = {}, L = {}, leak = {}, dealy = {}". format(M, step, L, leak, delay)) sig_inf = np.roll(sig_inf, delay) sig_result = affine_projection_filter(main=sig_sp, ref=sig_inf, M=M, step=step, L=L, leak=leak) sf.write( r"out/out_ap_null_M_{}_step_{}_L_{}_leak_{}_delay_{}.wav".format( M, step, L, leak, delay), sig_result, sr) sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base = calc_sdr_impr_metric( ref_sp, ref_mus, mix, sig_result) print(base_name) print( "sdr_impr, sir_impr, sar_impr = {}, {}, {}, sdr_base, sir_base, sar_base = {}, {}, {}\n" .format(sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base))
def params_iterate_null(): #base_name = 'out_mus1_spk1_snr_-10' base_name = 'out_wgn_spk_snr_-10' config = cfg.ConfigParser() config.read(os.path.join(r'./data/_sdr_test', base_name, 'config.cfg')) in_Main = r'./data/_sdr_test/' + base_name + r'/ds_mix.wav' in_Main_Sp = r'./data/_sdr_test/' + base_name + r'/ds_spk.wav' in_Main_Mus = r'./data/_sdr_test/' + base_name + r'/ds_mus.wav' # ################################################################# # 1.0 - read PROFILE vert_mic_count = int(config['MIC_CFG']['vert_mic_count']) hor_mic_count = int(config['MIC_CFG']['hor_mic_count']) dHor = float(config['MIC_CFG']['dhor']) dVert = float(config['MIC_CFG']['dvert']) max_len_sec = int(config['MIC_CFG']['max_len_sec']) n_fft = int(config['MIC_CFG']['fft_size']) angle_h = -float(config['FILTER_CFG']['angle_h']) angle_v = -float(config['FILTER_CFG']['angle_v']) angle_inf_h = -float(config['FILTER_CFG']['angle_inf_h']) angle_inf_v = -float(config['FILTER_CFG']['angle_inf_v']) in_wav_path = r'./data/_sdr_test/' + base_name + r'/mix' out_wav_path = r'./data/out/' _mix_start = float(config['FILTER_CFG']['start_mix_time']) _mix_end = 30 ################################################################# ################################################################# # 1.0 - Read signal x_all_arr, sr = read_mic_wav_from_folder(in_wav_path, vert_mic_count, hor_mic_count, max_len_sec=max_len_sec) ref_sp, _ = sf.read(in_Main_Sp) ref_mus, _ = sf.read(in_Main_Mus) mix, _ = sf.read(in_Main) x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] ref_sp = ref_sp[:(np.int32)((_mix_end - _mix_start) * sr)] ref_mus = ref_mus[:(np.int32)((_mix_end - _mix_start) * sr)] mix = mix[(np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] (n_channels, n_samples) = x_all_arr.shape print("Array data read done!") print(" n_channels = ", n_channels) print(" n_samples = ", n_samples) print(" freq = ", sr) ################################################################# # 2 - Do STFT stft_all = stft_arr(x_all_arr, fftsize=n_fft) (n_bins, n_sensors, n_frames) = stft_all.shape print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" n_frames = ", n_frames) ################################################################# # 3 - Calc steering vector print('Calc steering vector!') print(' (angle_h, angle_v) = ', angle_h, angle_v) print(' (angle_inf_h, angle_inf_v) = ', angle_inf_h, angle_inf_v) sensor_positions = get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = get_source_position(angle_h, angle_v, radius=6.0) source_position_inf = get_source_position(angle_inf_h, angle_inf_v, radius=6.0) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) d_arr_inf = propagation_vector_free_field(sensor_positions, source_position_inf, N_fft=n_fft, F_s=sr) ################################################################# # 4 - Calc DS beamforming in desired and noise direction result_spec = ds_beamforming(stft_all, d_arr.T) result_spec_inf = ds_beamforming(stft_all, d_arr_inf.T) ################################################################# # 5 - ISTFT sig_sp = istft(result_spec.transpose((1, 0)), overlap=2) sig_inf = istft(result_spec_inf.transpose((1, 0)), overlap=2) sf.write(r"out/out_ds_sp.wav", sig_sp, sr) sf.write(r"out/out_ds_inf.wav", sig_inf, sr) ################################################################# # 5.1 - NULL filter + cyclic parameters out_spec, _ = null_filter(stft_all, d_arr_sp=d_arr.T, d_arr_inf=d_arr_inf.T) sig_out = istft(out_spec.transpose((1, 0)), overlap=2) sf.write(r"out/out_null.wav", sig_out, sr) #result_spec, _ = null_filter_ex(stft_mix_arr, d_arr_sp=d_arr.T, lst_d_arr_inf=[d_arr_inf.T, d_arr_inf_d1.T, d_arr_inf_d2.T]) sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base = calc_sdr_impr_metric( ref_sp, ref_mus, mix, sig_out) print(base_name) print( "sdr_impr, sir_impr, sar_impr = {}, {}, {}, sdr_base, sir_base, sar_base = {}, {}, {}\n" .format(sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base)) print('---------------------------------------------')
def params_iterate(): base_name = 'out_mus1_spk1_snr_-10' #base_name = 'out_wgn_spk_snr_-10' config = cfg.ConfigParser() config.read(os.path.join(r'./data/_sdr_test', base_name, 'config.cfg')) in_Main = r'./data/_sdr_test/' + base_name + r'/ds_mix.wav' in_Main_Sp = r'./data/_sdr_test/' + base_name + r'/ds_spk.wav' in_Main_Mus = r'./data/_sdr_test/' + base_name + r'/ds_mus.wav' # ################################################################# # 1.0 - read PROFILE vert_mic_count = int(config['MIC_CFG']['vert_mic_count']) hor_mic_count = int(config['MIC_CFG']['hor_mic_count']) dHor = float(config['MIC_CFG']['dhor']) dVert = float(config['MIC_CFG']['dvert']) max_len_sec = int(config['MIC_CFG']['max_len_sec']) n_fft = int(config['MIC_CFG']['fft_size']) angle_h = -float(config['FILTER_CFG']['angle_h']) angle_v = -float(config['FILTER_CFG']['angle_v']) angle_inf_h = -float(config['FILTER_CFG']['angle_inf_h']) angle_inf_v = -float(config['FILTER_CFG']['angle_inf_v']) in_wav_path = r'./data/_sdr_test/' + base_name + r'/mix' out_wav_path = r'./data/out/' _mix_start = float(config['FILTER_CFG']['start_mix_time']) _mix_end = 30 ################################################################# ################################################################# # 1.0 - Read signal x_all_arr, sr = read_mic_wav_from_folder(in_wav_path, vert_mic_count, hor_mic_count, max_len_sec=max_len_sec) ref_sp, _ = sf.read(in_Main_Sp) ref_mus, _ = sf.read(in_Main_Mus) mix, _ = sf.read(in_Main) x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] ref_sp = ref_sp[:(np.int32)((_mix_end - _mix_start) * sr)] ref_mus = ref_mus[:(np.int32)((_mix_end - _mix_start) * sr)] mix = mix[(np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] (n_channels, n_samples) = x_all_arr.shape print("Array data read done!") print(" n_channels = ", n_channels) print(" n_samples = ", n_samples) print(" freq = ", sr) ################################################################# # 2 - Do STFT stft_all = stft_arr(x_all_arr, fftsize=n_fft) (n_bins, n_sensors, n_frames) = stft_all.shape print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" n_frames = ", n_frames) ################################################################# # 3 - Calc steering vector print('Calc steering vector!') print(' (angle_h, angle_v) = ', angle_h, angle_v) print(' (angle_inf_h, angle_inf_v) = ', angle_inf_h, angle_inf_v) sensor_positions = get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = get_source_position(angle_h, angle_v, radius=6.0) source_position_inf = get_source_position(angle_inf_h, angle_inf_v, radius=6.0) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) d_arr_inf = propagation_vector_free_field(sensor_positions, source_position_inf, N_fft=n_fft, F_s=sr) ################################################################# # 4 - Calc DS beamforming in desired and noise direction result_spec = ds_beamforming(stft_all, d_arr.T) result_spec_inf = ds_beamforming(stft_all, d_arr_inf.T) ################################################################# # 5 - ISTFT sig_sp = istft(result_spec.transpose((1, 0)), overlap=2) sig_inf = istft(result_spec_inf.transpose((1, 0)), overlap=2) sf.write(r"out/out_ds_sp.wav", sig_sp, sr) sf.write(r"out/out_ds_inf.wav", sig_inf, sr) ################################################################# # 6.1 - AP filter + cyclic parameters # M = 200 # step = 0.05 # L = 5 # leak = 0.0 # delay = -5 params = [ #(150, 0.005, 5, 0.001, 0), (150, 0.005, 5, 0.001, 0), (200, 0.05, 5, 0.001, 0), ] for (M, step, L, leak, delay) in params: print("process M = {}, step = {}, L = {}, leak = {}, delay = {}". format(M, step, L, leak, delay)) sig_inf = np.roll(sig_inf, delay) sig_result = affine_projection_filter(main=sig_sp, ref=sig_inf, M=M, step=step, L=L, leak=leak) sf.write( r"out/out_ap_null_M_{}_step_{}_L_{}_leak_{}_delay_{}.wav".format( M, step, L, leak, delay), sig_result, sr) sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base = calc_sdr_impr_metric( ref_sp, ref_mus, mix, sig_result) print(base_name) print( "sdr_impr, sir_impr, sar_impr = {}, {}, {}, sdr_base, sir_base, sar_base = {}, {}, {}\n" .format(sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base)) print('---------------------------------------------')
weights = np.load( r'./mic_utils/room_simulation\room_simulation_Gleb\weights14.npy') n_iter = 15 n_comp = 2 res = ilrma(stft_all_arr_ilrma, n_iter=n_iter, n_components=n_comp, W0=weights) entr = np.zeros(res.shape[-1]) for i in range(res.shape[-1]): for j in range(res.shape[1]): entr[i] += entropy(np.real(res[:, j, i] * np.conj(res[:, j, i]))) resulting_sig = istft(res[:, :, np.argmin(entr)], overlap=2) # def demix(X, W): # Y = np.zeros(X.shape, dtype=X.dtype) # for f in range(X.shape[1]): # Y[:,f,:] = np.dot(X[:,f,:], np.conj(W[f,:,:])) # return Y # # Y = demix(stft_all_arr_ilrma, weights) # resulting_sig = istft(Y[:,:,8], overlap=2) # sf.write(r'./out/Simulation/MVDR+ILRMA/test.wav', resulting_sig, sr) # 3.0 Calculate average amd make a mask def double_exp_average(X,
source_position, N_fft=n_fft, F_s=sr) d_arr_inf = propagation_vector_free_field(sensor_positions, source_position_inf, N_fft=n_fft, F_s=sr) ################################################################# # 4 - Calc RTF steering vector print('Calc RTF steering vector!') #result_spec_rtf = rtf_filter(stft_mix, stft_chirp_sp_arr, 'simple') result_spec_rtf = rtf_filter(stft_mix, stft_chirp_noise_arr, 'simple') ################################################################# # 5 - Do DS beamforming result_sp = ds_beamforming(stft_mix, d_arr.T) result_noise = ds_beamforming(stft_mix, d_arr_inf.T) ################################################################# # 5 - Write result sig_out = istft(result_spec_rtf.transpose((1, 0)), overlap=n_overlap) sf.write(r"out/out_DS_rtf.wav", sig_out, sr) sig_out = istft(result_sp.transpose((1, 0)), overlap=n_overlap) sf.write(r"out/out_DS_sp.wav", sig_out, sr) sig_out = istft(result_noise.transpose((1, 0)), overlap=n_overlap) sf.write(r"out/out_DS_noise.wav", sig_out, sr)
def ds_respk(): # # ################################################################# # # 1.0 - simulation showroom, wgn WBN_16000hz # n_fft = 512 # n_overlap = 2 # # intermic_distance = 0.0457 # mic_count = 4 # in_wav_path = r'./data/_sim_shoroom/WBN_16000hz/4mic_output.wav' # out_wav_path = r'./data/out/' # _chirp_noise_start = 0 # _chirp_noise_end = 59 # _mix_start = 0 # _mix_end = 59 # angle_azimuth = 150.0 # ################################################################# # 1.0 - simulation showroom, wgn 2800_3800 n_fft = 512 n_overlap = 2 intermic_distance = 0.0457 mic_count = 4 #in_wav_path = r'./data/_sim_shoroom/WBN_2800_3800/4mic_output.wav' in_wav_path = r'./data/_sim_shoroom/WBN_2800_3800/4mic_output_reflection_0.wav' out_wav_path = r'./data/out/' _chirp_noise_start = 0 _chirp_noise_end = 59 _mix_start = 0 _mix_end = 59 angle_azimuth = 0.0 # # ################################################################# # # 1.0 - stc-h873 ex2 # n_fft = 512 # n_overlap = 2 # # intermic_distance = 0.05 # mic_count = 2 # in_wav_path = r'./data/_re_spk_ex2/stc-h873.wav' # out_wav_path = r'./data/out/' # _chirp_noise_start = 47 # _chirp_noise_end = 60 + 3 # _mix_start = 60 + 9 # _mix_end = 3*60 + 31 # angle_azimuth = 0.0 # # ################################################################# # # 1.0 - respeaker_mic_array ex2 # n_fft = 512 # n_overlap = 2 # # intermic_distance = 0.0457 # mic_count = 4 # in_wav_path = r'./data/_re_spk_ex2/respeaker_mic_array.wav' # out_wav_path = r'./data/out/' # _chirp_noise_start = 40 # _chirp_noise_end = 56 # _mix_start = 60 # _mix_end = 3*60 + 22 # angle_azimuth = -50.0 # # ################################################################# # # 1.0 - respeaker_core_v2 ex2 # n_fft = 512 # n_overlap = 2 # # intermic_distance = 0.0463 # mic_count = 6 # in_wav_path = r'./data/_re_spk_ex2/respeaker_core_v2.wav' # out_wav_path = r'./data/out/' # _chirp_noise_start = 52 # _chirp_noise_end = 69 # _mix_start = 70 # _mix_end = 3*60 + 35 # angle_azimuth = 30.0 # # ################################################################# # # 1.0 - respeaker_core_v2 ex1 # n_fft = 512 # n_overlap = 2 # # intermic_distance = 0.0463 # mic_count = 6 # in_wav_path = r'./data/_re_spk_ex1/respeaker_core_v2.wav' # out_wav_path = r'./data/out/' # _chirp_noise_start = 15 # _chirp_noise_end = 60 + 48 # _mix_start = 10 # _mix_end = 15 # angle_azimuth = 30.0 # # ################################################################# # # 1.0 - respeaker_mic_array ex1 # n_fft = 512 # n_overlap = 2 # # intermic_distance = 0.0457 # mic_count = 4 # in_wav_path = r'./data/_re_spk_ex2/respeaker_mic_array.wav' # out_wav_path = r'./data/out/' # _chirp_noise_start = 38 # _chirp_noise_end = 56 # _mix_start = 38 # _mix_end = 56 # angle_azimuth = -50.0 ################################################################# # 1.0 - Read signal x_all_arr, sr = read_mic_wav_from_file(in_wav_path, mic_count) (n_channels, n_samples) = x_all_arr.shape print("Array data read done!") print(" n_channels = ", n_channels) print(" n_samples = ", n_samples) print(" freq = ", sr) x_chirp_noise_arr = x_all_arr[:, (np.int32)(_chirp_noise_start * sr):(np.int32)(_chirp_noise_end * sr)] x_mix_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] ################################################################# # 2 - Do STFT stft_mix = stft_arr(x_mix_arr, fftsize=n_fft, overlap=n_overlap) stft_chirp_noise_arr = stft_arr(x_chirp_noise_arr, fftsize=n_fft, overlap=n_overlap) (n_bins, n_sensors, n_frames) = stft_mix.shape print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" n_frames = ", n_frames) ################################################################# # 3 - Plot DN angle_step = 1 print("Begin steering calc ...") arr_angle = range(-180, 180, angle_step) arr_d_arr = np.zeros((len(arr_angle), n_sensors, n_bins), dtype=np.complex) print('arr_d_arr = ', arr_d_arr.shape) for i, angle in enumerate(arr_angle): sensor_positions = get_sensor_positions_respeaker( intermic_distance, mic_count) source_position = get_source_position_respeaker(azimuth=angle, polar=90) arr_d_arr[i, :, :] = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) print("Steering calc done!") ################################################################# # 4 - Calc map POW = np.zeros((len(arr_angle))) print("Begin calc map ...") for i, angle_h in enumerate(arr_angle): print(" process angle = {}".format(angle_h)) d_arr = arr_d_arr[i, :, :] # DS beamforming result_spec = ds_beamforming(stft_chirp_noise_arr, d_arr.T) POW[i] = np.real( np.sum(result_spec * np.conjugate(result_spec)) / n_frames) print("Calc map done!") ################################################################# # 5 - Scale to power ch_0_0 P0 = np.sum(stft_chirp_noise_arr[:, 0, :] * np.conjugate(stft_chirp_noise_arr[:, 0, :])) / n_frames POW = POW / P0 ################################################################# # 6 - Plot DN plt.plot(arr_angle, POW) plt.xlabel('angle (s)') plt.ylabel('pow_res/pow_s0') plt.title('DS alg') plt.grid(True) plt.savefig(r".\out\DS_mic{}.png".format(mic_count)) plt.show() ################################################################# # 7 - Do DS beamforming print('Calc steering vector!') print(' (angle_azimuth) = ', angle_azimuth) sensor_positions = get_sensor_positions_respeaker(intermic_distance, mic_count) source_position = get_source_position_respeaker(azimuth=angle_azimuth, polar=90) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) ################################################################# # 4 - Calc DS filter output result_spec = ds_beamforming(stft_mix, d_arr.T) print('Calc RTF steering vector!') result_spec_rtf = rtf_filter(stft_mix, stft_chirp_noise_arr, 'simple') ################################################################# # 5 inverse STFT and save sig_out = istft(result_spec.transpose((1, 0)), overlap=n_overlap) sf.write(r"out/out_DS.wav", sig_out, sr) sig_out = istft(result_spec_rtf.transpose((1, 0)), overlap=n_overlap) sf.write(r"out/out_DS_rtf.wav", sig_out, sr)
print(' (angle_h, angle_v) = ', angle_h, angle_v) sensor_positions = get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = get_source_position(angle_h, angle_v, radius=6.0) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) # 4 - DS filter result_spec = ds_beamforming(stft_mix, d_arr.T) # 5 - inverse STFT and save sig_out = istft(result_spec.transpose((1, 0)), overlap=2) out_ds_path = r'{}/tmp_ds.wav'.format(os.path.dirname(out_wav_path)) sf.write(out_ds_path, sig_out, sr) # 6 - get noise mask print('Get noise mask form neural net!') # shape - (time, freq, 2) config_path = r'/home/stc/MA_ALG/datasets/test_ma/' \ r'chimera_v12/9_chimera.json' in_model_path = r'/home/stc/MA_ALG/datasets/test_ma/chimera_v12/checkpoint/' frozen_model_path = r'/home/stc/MA_ALG/datasets/test_ma/chimera_frozen/model_chimera_v11.pb' mask = ChimeraPredictFrozen(frozen_model_path).predict_mask(out_ds_path)
def do_ds(): ################################################################# # 1.0 - out_mus1_spk1_snr_-10 PROFILE vert_mic_count = 6 hor_mic_count = 11 dHor = 0.035 dVert = 0.05 max_len_sec = 60 n_fft = 512 # (angle_hor_log, angle_vert_log) = (7.1539, 7.39515) (angle_hor_log, angle_vert_log) = (-16.0721, -0.163439) angle_h = -angle_hor_log angle_v = -angle_vert_log _mix_start = 10 _mix_end = 50 in_wav_path = r'./data/_sdr_test/out_mus1_spk1_snr_-15/mix/' out_wav_path = r'./data/out/' ################################################################# ################################################################# # 1.0 - Read signal x_all_arr, sr = read_mic_wav_from_folder(in_wav_path, vert_mic_count, hor_mic_count, max_len_sec=max_len_sec) x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] (n_channels, n_samples) = x_all_arr.shape print("Array data read done!") print(" n_channels = ", n_channels) print(" n_samples = ", n_samples) print(" freq = ", sr) ################################################################# # 2 - Do STFT stft_all = stft_arr(x_all_arr, fftsize=n_fft) (n_bins, n_sensors, n_frames) = stft_all.shape print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" n_frames = ", n_frames) ################################################################# # 3 - Calc steering vector print('Calc steering vector!') print(' (angle_h, angle_v) = ', angle_h, angle_v) sensor_positions = get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = get_source_position(angle_h, angle_v, radius=6.0) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) ################################################################# # 4 - Calc DS filter output result_spec = ds_beamforming(stft_all, d_arr.T) ################################################################# # 5 inverse STFT and save sig_out = istft(result_spec.transpose((1, 0)), overlap=2) sf.write(r"out/out_DS.wav", sig_out, sr)
def main2(): X_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mix_sp.wav' N_ideal_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mus_sp.wav' N_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mix_mus.wav' # N_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mus_sp.wav' # N_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mix_mus.wav' OUT_wav_path = r'./out/ADAPT_SAD/SNR_-8/_result.wav' n_fft = 512 overlap = 2 #################################################### # 1 - Load signal X_sig, rate = sf.read(X_wav_path) N_ideal_sig, rate = sf.read(N_ideal_wav_path) N_sig, rate = sf.read(N_wav_path) # X_sig = np.roll(X_sig, -10) X_spec = stft(X_sig, fftsize=n_fft, overlap=overlap) N_spec = stft(N_sig, fftsize=n_fft, overlap=overlap) N_ideal_spec = stft(N_ideal_sig, fftsize=n_fft, overlap=overlap) n_frames, b_bins = X_spec.shape start = time.time() #OUT = spectral_substract_filter(stft_main=X_spec, stft_ref=N_spec, alfa_PX=0.001, alfa_PN=0.00199199) #OUT = compensate_ref_ch_filter(stft_main=X_spec, stft_ref=N_spec, alfa=0.75) #OUT = compensate_ref_ch_filter_ex(stft_main=X_spec, stft_ref=N_spec, alfa=.0075, beta=0.95) OUT = smb_filter(stft_main=X_spec, stft_ref=N_spec, gain_max=18) # 6.1 - AP filter + cyclic parameters M = 200 step = 0.05 L = 5 leak = 0.1 delay = -5 # AP filter #sig_result = affine_projection_filter(main=X_sig, ref=N_sig, M=M, step=step, L=L, leak=leak) end = time.time() print("Elapsed (with compilation) = %s" % (end - start)) ################################################ start = time.time() for g in range(1, 28): OUT = smb_filter(stft_main=X_spec, stft_ref=N_spec, gain_max=g) end = time.time() print("Elapsed (with compilation) = %s" % (end - start)) ################################################ # NLMS #sig_result = lms_filter(main=X_sig, ref=N_sig, M=M, step=step, leak=leak, norm=True) # LMS #sig_result = lms_filter(main=X_sig, ref=N_sig, M=M, step=step, leak=leak, norm=False) # #################################################### # # 4 - Plot # n_bin = 50 # T = np.arange(0, n_frames) * (n_fft/overlap) / rate # E1 = np.abs(X_spec)[:, n_bin] # E2 = np.abs(N_ideal_spec)[:, n_bin] # E3 = np.abs(est_noise)[:, n_bin] # # plt.plot(T, E1,'r--', T, E2,'b', T, E3,'g') # plt.show() # #################################################### # # X_sig # plt.plot(T, E1,'r--', T, E2,'b', T, E3,'g') # plt.show() sig_out = istft(OUT, overlap=overlap) #sig_out = sig_result sf.write(OUT_wav_path, sig_out, rate)
psd_noise_matrix.shape[-1]) w = get_mvdr_vector(d_arr.T, psd_noise_matrix) ################################################################# # 4 - Calc filter output result_spec = cov_matrix_tracking(stft_noise, stft_mix, w * mic_count, filter_type='blocking_matrix') ################################################################# # 5 - Do align align_stft_arr = ds_align(stft_mix, d_arr.T) print('Align mix_arr done!') ################################################################# # 6 - Calc zelin filter output result_spec_, H = zelin_filter(stft_arr=align_stft_arr, alfa=0.7, alg_type=0) print('Calc zelin filter output done!') ################################################################# # 7 - Calc tracking + Zelin filter output result_spec = result_spec * H ################################################################# # 8 inverse STFT and save sig_out = istft(result_spec.T, overlap=2) sf.write(r"out/out_cov_matrix_tracking_zelin.wav", sig_out, sr)
axis=-1) weights = np.load( r'./mic_utils/room_simulation\room_simulation_Gleb\weights14.npy') res = ilrma(stft_all_arr_ilrma, n_iter=15, n_components=2, W0=weights, seed=0) entr = np.zeros(res.shape[-1]) for i in range(res.shape[-1]): for j in range(res.shape[1]): entr[i] += entropy(np.real(res[:, j, i] * np.conj(res[:, j, i]))) resulting_sig = istft(res[:, :, np.argmin(entr)], overlap=2) sf.write(r'./out/simulation/res_sig.wav', resulting_sig, sr) average_sig = double_exp_average(resulting_sig, sr) average_sig[-300:] = average_sig[-300] average_sig[:300] = average_sig[300] mask = make_mask(average_sig, percent_threshold=100) mask_frames = mask_to_frames(mask, int(n_fft), int(n_fft / 2)) # plt.plot(mask_frames) # plt.show() print('Mask is ready!')
def ds_respk(): # ################################################################# # 1.0 - AMI dataset small session n_fft = 512 n_overlap = 2 r_circular_array = 0.1 mic_count = 8 in_wav_path = r'./data/_ami_data' out_wav_path = r'./data/out/' _mix_start = 15.0 _mix_end = 22.0 angle_azimuth = 64.0 ################################################################# # 1.0 - Read signal x_all_arr, sr = read_mic_wav_from_path(in_wav_path, mic_count) (n_channels, n_samples) = x_all_arr.shape print("Array data read done!") print(" n_channels = ", n_channels) print(" n_samples = ", n_samples) print(" freq = ", sr) x_mix_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] ################################################################# # 2 - Do STFT stft_mix = stft_arr(x_mix_arr, fftsize=n_fft, overlap=n_overlap) (n_bins, n_sensors, n_frames) = stft_mix.shape print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" n_frames = ", n_frames) ################################################################# # 3 - Plot DN angle_step = 1 print("Begin steering calc ...") arr_angle = range(-180, 180, angle_step) arr_d_arr = np.zeros((len(arr_angle), n_sensors, n_bins), dtype=np.complex) print('arr_d_arr = ', arr_d_arr.shape) for i, angle in enumerate(arr_angle): sensor_positions = get_sensor_positions_circular( r_circular_array, mic_count) source_position = get_source_position_circular(azimuth=angle, polar=90.0) arr_d_arr[i, :, :] = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) print("Steering calc done!") ################################################################# # 4 - Calc map POW = np.zeros((len(arr_angle))) print("Begin calc map ...") for i, angle_h in enumerate(arr_angle): print(" process angle = {}".format(angle_h)) d_arr = arr_d_arr[i, :, :] # DS beamforming result_spec = ds_beamforming(stft_mix, d_arr.T) POW[i] = np.real( np.sum(result_spec * np.conjugate(result_spec)) / n_frames) print("Calc map done!") ################################################################# # 5 - Scale to power ch_0_0 P0 = np.sum(stft_mix[:, 0, :] * np.conjugate(stft_mix[:, 0, :])) / n_frames POW = POW / P0 ################################################################# # 6 - Plot DN plt.plot(arr_angle, POW) plt.xlabel('angle (s)') plt.ylabel('pow_res/pow_s0') plt.title('DS alg') plt.grid(True) plt.savefig(r".\out\DS_mic{}.png".format(mic_count)) plt.show() ################################################################# # 7 - Do DS beamforming print('Calc DS beamforming!') print(' (angle_azimuth) = ', angle_azimuth) sensor_positions = get_sensor_positions_circular(r_circular_array, mic_count) source_position = get_source_position_circular(azimuth=angle_azimuth, polar=90.0) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) ################################################################# # 4 - Calc DS filter output result_spec = ds_beamforming(stft_mix, d_arr.T) ################################################################# # 5 inverse STFT and save sig_out = istft(result_spec.transpose((1, 0)), overlap=n_overlap) sf.write(r"out/out_DS_{}.wav".format(angle_azimuth), sig_out, sr)
print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" stft_noise_arr.shape = ", stft_noise_arr.shape) print(" stft_mix.shape = ", stft_mix.shape) print(" stft_sp_arr.shape = ", stft_sp_arr.shape) ################################################################# print('Calc steering vector!') print(' (angle_h, angle_v) = ', angle_h, angle_v) sensor_positions = get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = get_source_position(angle_h, angle_v) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) psd = get_power_spectral_density_matrix(stft_mix) psd = psd + 0.001 * np.identity(psd.shape[-1]) w = get_mvdr_vector(d_arr.T, psd) result_mvdr_spec = apply_beamforming_vector(w, stft_mix) sig_out = istft(result_mvdr_spec.transpose((1, 0)), overlap=4) sf.write(r"out/out_mvdr_mix.wav", sig_out, sr)
def main(): # ################################################################# # # 1.0 - LANDA PROFILE # vert_mic_count = 1 # hor_mic_count = 8 # dHor = 0.05 # dVert = 0.05 # max_len_sec = 60 # n_fft = 512 # n_overlap = 2 # # (angle_hor_log, angle_vert_log) = (16.0, 0.0) # angle_h = -angle_hor_log # angle_v = -angle_vert_log # # _mix_start = 17 # _mix_end = 40 # # in_wav_path = r'./data/_landa/' # out_wav_path = r'./data/out/' # ################################################################# ################################################################# # 1.0 - _du_hast PROFILE #vert_mic_count = 6 #hor_mic_count = 11 vert_mic_count = 1 hor_mic_count = 11 dHor = 0.035 dVert = 0.05 max_len_sec = 45 n_fft = 512 n_overlap = 2 (angle_hor_log, angle_vert_log) = (12.051, 5.88161) angle_h = -angle_hor_log angle_v = -angle_vert_log _mix_start = 17 _mix_end = 40 in_wav_path = r'./data/_du_hast/' out_wav_path = r'./data/out/' ################################################################# ################################################################# # 1.0 - Read signal x_all_arr, sr = read_mic_wav_from_folder(in_wav_path, vert_mic_count, hor_mic_count, max_len_sec=max_len_sec) x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)] (n_channels, n_samples) = x_all_arr.shape print("Array data read done!") print(" n_channels = ", n_channels) print(" n_samples = ", n_samples) print(" freq = ", sr) ################################################################# # 2 - Do STFT stft_all = stft_arr(x_all_arr, fftsize=n_fft, overlap=n_overlap) (n_bins, n_sensors, n_frames) = stft_all.shape print("STFT calc done!") print(" n_bins = ", n_bins) print(" n_sensors = ", n_sensors) print(" n_frames = ", n_frames) ################################################################# # 3 - Calc steering vector print('Calc steering vector!') print(' (angle_h, angle_v) = ', angle_h, angle_v) sensor_positions = get_sensor_positions(hor_mic_count, vert_mic_count, dHor=dHor, dVert=dVert) source_position = get_source_position(angle_h, angle_v, radius=6.0) d_arr = propagation_vector_free_field(sensor_positions, source_position, N_fft=n_fft, F_s=sr) ################################################################# # Reshape to (nframes, nfrequencies, nchannels) M_spec = stft_all.transpose((2, 0, 1)) def callback_fn(X): print(' invoke callback_fn') # #(nfrequencies, nchannels, nchannels) # W = np.array([np.eye(n_sensors, n_sensors) for f in range(n_bins)], dtype=M_spec.dtype) # for i in range(n_bins): # W[i, : , 0 ] = d_arr[:, i]/8.0 # Y = np.zeros((n_frames, n_bins, n_sensors), dtype=M_spec.dtype) # def demix(Y, X, W): # for f in range(n_bins): # Y[:,f,:] = np.dot(X[:,f,:], np.conj(W[f,:,:])) # demix(Y, M_spec, W) # # IVA Demix Y = pyroomacoustics.bss.auxiva(M_spec, n_iter=20, proj_back=True, callback=callback_fn) # Save result for i in range(Y.shape[2]): sig_out = istft(Y[:, :, i], overlap=n_overlap) sf.write(r'out/iva_res_{}.wav'.format(i), sig_out, sr)
def main(): seg_path = r'./out/ADAPT_SAD/ds_spk.seg' X_wav_path = r'./out/ADAPT_SAD/out_DS_sp.wav' N_wav_path = r'./out/ADAPT_SAD/out_DS_inf.wav' S_wav_path = r'./out/ADAPT_SAD/ds_spk.wav' n_fft = 512 overlap = 256 #################################################### # 1 - Load signal X_sig, rate = sf.read(X_wav_path) N_sig, rate = sf.read(N_wav_path) S_sig, rate = sf.read(S_wav_path) #################################################### # 2 - SFFT signal X_spec = stft(X_sig, fftsize=n_fft, overlap=2) N_spec = stft(N_sig, fftsize=n_fft, overlap=2) S_spec = stft(S_sig, fftsize=n_fft, overlap=2) (n_frames, n_bins) = X_spec.shape assert X_spec.shape == N_spec.shape and X_spec.shape == S_spec.shape, 'X_spec.shape == N_spec.shape and X_spec.shape == S_spec.shape' print('X_spec.shape = ', X_spec.shape) print('N_spec.shape = ', N_spec.shape) print('S_spec.shape = ', S_spec.shape) #################################################### # 3 - Read true time segmentation count_frames = X_spec.shape[0] true_time_segm, freq = read_seg_file_pause(seg_file=seg_path) true_frame_segm = convert_time_segm_to_frame_segm( time_seg=true_time_segm, count_frames=count_frames, fs=freq, overlap=overlap) true_frame_segm = 1 - true_frame_segm #################################################### # 4 - Plot T = np.arange(0, n_frames) * overlap / rate E = np.sum(np.abs(X_spec), axis=1) E = E / np.max(E) plt.plot(T, E, T, true_frame_segm) plt.show() #################################################### # Filter signal # S_spec = spectral_substract_filter(stft_main= X_spec , stft_ref= N_spec, alfa_PX = 0.01, alfa_PN = 0.99) # S_spec = smb_filter(stft_main=X_spec, stft_ref=N_spec, gain_max=18) #################################################### # ISFFT signal and write result sig_out = istft(S_spec, overlap=2) sf.write(r'./out/ADAPT_SAD/_result.wav', sig_out, rate) #################################################### # initialize the filter rls = pyroomacoustics.adaptive.RLS(30) # run the filter on a stream of samples for i in range(100): rls.update(X_sig[i], N_sig[i]) # the reconstructed filter is available print('Reconstructed filter:', rls.w)
# plt.imshow(show_mask[0,:,:]) # plt.xlabel('Time') # plt.ylabel('Freq') # # plt.subplot(312) # plt.imshow(show_mask[1,:,:]) # plt.xlabel('Time') # plt.ylabel('Freq') # # plt.subplot(313) # plt.imshow(spec_ch_0_0) # plt.xlabel('Time') # plt.ylabel('Freq') # # plt.show() ################################################################# # 4 - Save result result_spec = np.zeros((2, n_bins, n_frames), dtype=np.complex) for k in range(2): for f in range(n_bins): for t in range(n_frames): result_spec[k, f, t] = stft_all[f, 0, t] * perm_mask[k, f, t] #result_spec[k, f, t] = stft_all[f, 0, t] * mask[k, f, t] for k in range(2): sig_out = istft(result_spec[k, :, :].T, overlap=2) sf.write(r"out/out_CGMM_" + str(k) + ".wav", sig_out, sr)
spec_sp = ds_beamforming(stft_all, d_arr.T) spec_inf = ds_beamforming(stft_all, d_arr_inf.T) gain_correction = np.zeros((n_bins), dtype=np.complex) for i in range(n_bins): d1 = d_arr[:, i] d2 = d_arr_inf[:, i] eq_i = np.dot(np.conj(d2), d1) gain_correction[i] = eq_i / n_sensors spec_corr_inf = np.expand_dims(gain_correction, axis=1) * spec_inf #result_spec = spectral_substract_filter(stft_main=spec_sp, stft_ref=spec_inf, alfa_PX=0.01, alfa_PN=0.099) result_spec = spectral_substract_filter(stft_main=spec_sp, stft_ref=spec_corr_inf, alfa_PX=0.01, alfa_PN=0.099) #result_spec = smb_filter(stft_main=spec_sp, stft_ref=spec_corr_inf, gain_max=18) sig_sp = istft(spec_sp.transpose((1, 0)), overlap=n_overlap) sig_inf = istft(spec_inf.transpose((1, 0)), overlap=n_overlap) sig_corr_inf = istft(spec_corr_inf.transpose((1, 0)), overlap=n_overlap) sig_result = istft(result_spec.transpose((1, 0)), overlap=n_overlap) sf.write(r"out/out_HARD_spk.wav", sig_sp, sr) sf.write(r"out/out_HARD_inf.wav", sig_inf, sr) sf.write(r"out/out_HARD_corr_inf.wav", sig_corr_inf, sr) sf.write(r"out/out_HARD_result.wav", sig_result, sr)
psd_noise_matrix = get_power_spectral_density_matrix(stft_noise_arr) print('Calc psd matrix done!') print(' psd_noise_matrix.shape = ', psd_noise_matrix.shape) ################################################################# # 6 - Apply MVDR type_reg = 1 reg_p = 0.001 w = get_mvdr_vector_svd(d_arr.T, psd_noise_matrix, type_reg=type_reg, r=reg_p) result_spec = apply_beamforming_vector(w, stft_mix_arr) ################################################################# # 6 inverse STFT and save sig_out = istft(result_spec.transpose((1, 0)), overlap=2) sf.write(r"out/out_mvdr_svd_type_{}_r_{}.wav".format(type_reg, reg_p), sig_out, sr) ################################################################# # 7.1 - Do align align_stft_arr = ds_align(stft_mix_arr, d_arr.T) ################################################################# # 7.2 save ds output result_spec = align_stft_arr.sum(axis=1) / (hor_mic_count * vert_mic_count) sig_out = istft(result_spec.transpose((1, 0)), overlap=2) sf.write(r"out/ds.wav", sig_out, sr)
# f_ref = r'D:\REP\svn_MicArrAlgorithm2\MA_PY\out\out_GSC_Z.wav' # f_out = r'out\out_MN_GSC_1.wav' speech_distribution_coeff_path = r'mic_utils\alg_data\gg_params_freq_f_scale.npy' ################################################################# # 1.0 - Read signal y_main, sr = sf.read(f_main, dtype=np.float64) y_ref, sr = sf.read(f_ref, dtype=np.float64) ################################################################# # 2.0 - STFT signal stft_main = stft(y_main, fftsize=512, overlap=2) stft_ref = stft(y_ref, fftsize=512, overlap=2) ################################################################# # 3.0 - Filter signal #stft_out = maximize_kutrosis_filter(stft_main, stft_ref) stft_out = maximize_negentropy_filter( stft_main, stft_ref, speech_distribution_coeff_path=speech_distribution_coeff_path) ################################################################# # 4.0 - ISFFT signal sig_out = istft(stft_out, overlap=2) ################################################################# # 5.0 - Write output sf.write(f_out, sig_out, sr)