import numpy as np import librosa import random import pickle import os import torch from torch.utils.data import Dataset, DataLoader from speechbrain.processing.signal_processing import reverberate from torch.nn.utils.rnn import pad_sequence def changed_index(ind, step = 0): ind_bool = ind < ind.min() - 1 if step == -1 : ind_bool[1:] = (ind+1)[:-1] == ind[1:] else: ind_bool[:-1] = (ind-step)[1:] == ind[:-1] ind_bool = ~ind_bool return ind_bool def post_processing_VAD(vad_out, goal = 1, len_frame_ms = 20, sensitivity_ms = 200): """Post-processing of VAD models to change 0 label0 with 1 labels according to a sensitivity. Arguments --------- vad_out : float (Tensor) Output of the VAD model. goal : int (Tensor) The goal of change. len_frame_ms : float Length of decision frame. sensitivity_ms : float Threshold to change labels that are less than it. Returns ------- vad_out : float (Tensor) The pre-processed output. """ vad_out = torch.tensor(vad_out) Th = max(int(sensitivity_ms // len_frame_ms), 1) ind0,ind1 = torch.where(vad_out== goal) if len(ind0) != 0: ind1_max = vad_out.shape[-1] - 1 ind0_last_bool = changed_index(ind0.clone()) ind0_last = torch.where(ind0_last_bool)[0] ind0_first = torch.zeros_like(ind0_last) ind0_first[1:] = ind0_last[:-1] + 1 ind0_first[0] = 0 ind1_l1_bool = changed_index(ind1.clone(), step = 1) ind1_l1_bool[ind0_last] = False ind1_f1_bool = changed_index(ind1.clone(), step = -1) ind1_f1_bool[ind0_first] = False dif_bool = ind1[ind1_f1_bool] - ind1[ind1_l1_bool] > Th + 1 l1_bool_temp = ind1_l1_bool[ind1_l1_bool].clone() l1_bool_temp[dif_bool] = False ind1_l1_bool[ind1_l1_bool.clone()] = l1_bool_temp f1_bool_temp = ind1_f1_bool[ind1_f1_bool].clone() f1_bool_temp[dif_bool] = False ind1_f1_bool[ind1_f1_bool.clone()] = f1_bool_temp second_ind = ind1[ind1_l1_bool].clone() for i in range(1,Th+1): second_ind = torch.clip(ind1[ind1_l1_bool]+i,0,ind1_max) desired_out = (second_ind < ind1[ind1_f1_bool]) temp_b = vad_out[ind0[ind1_l1_bool], second_ind].clone() temp_b[desired_out] = goal vad_out[ind0[ind1_l1_bool], second_ind] = temp_b.clone() vad_out = vad_out.numpy() return vad_out def creat_data_pathes(base_path, groups, g_scale, filenames = "train_files_path.txt"): total_paths = [] i = 0 for group_name in groups: with open( os.path.join(base_path,group_name,filenames ), 'rb') as fp: pathes = pickle.load(fp) pathes = pathes * g_scale[i] for path in pathes: total_paths.append(os.path.join(group_name,path)) i+=1 random.seed(12) random.shuffle(total_paths) random.shuffle(total_paths) return total_paths def pyannote_frame(len_inp,sinc_len): f = (len_inp - 251 + sinc_len)//sinc_len mp_0 = f // 3 conv1 = mp_0 - 4 mp_1 = conv1 // 3 conv2 = mp_1 - 4 mp_2 = conv2 // 3 # number of frames return mp_2, len_inp// mp_2 # length of frame def frame_target(target, num_frame, frame_shift): len_ = num_frame * frame_shift target = target[:,:len_] target = target.reshape(target.shape[0],num_frame,frame_shift) target = target.float().mean(-1,True) target[target>0.5] = 1 target[target <= 0.5] = 0 return target class VAD_DATASET(Dataset): def __init__(self, base_clean_path, base_noise_path, base_rever_path, base_lbl, clean_paths, noise_paths, reverb_paths, sampling_rate = 16000, max_length = 10 * 16000, max_noise_n = 2, #max = 2 t_reverb = -1, min_snr = -10, is_post_process = False, sens_ms = 100 ): self.base_clean_path = base_clean_path self.base_noise_path = base_noise_path self.base_rever_path = base_rever_path self.base_lbl = base_lbl self.clean_paths = clean_paths self.noise_paths = noise_paths self.reverb_paths = reverb_paths self.is_post_process = is_post_process self.sens_ms = sens_ms self.len_clean = len(clean_paths) self.len_noise = len(noise_paths) self.len_reverb = len(reverb_paths) self.sampling_rate = sampling_rate self.max_length = max_length self.max_noise_n = max_noise_n self.t_reverb = t_reverb self.len_snr = len(range(min_snr,31,2)) self.SNR_amount = range(min_snr,31,2) print("Dataset is ready.") def create_reverb(self, sig, reverb_filename): reverb_ = torch.from_numpy(self.load_sample(reverb_filename)) reverb_sig = reverberate(sig.unsqueeze(dim = 0), reverb_, rescale_amp= 'peak') return reverb_sig.squeeze() def load_sample(self, path): waveform, _ = librosa.load(path, sr=self.sampling_rate) return waveform def crop_noise(self, noise, len_x): len_n = len(noise) extra = len_n - len_x if extra > 0: first_ind = random.randint(0,extra - 1) noise = noise[first_ind:first_ind+len_x] return noise def crop_audio(self, x): len_x = len(x) extra = len_x - self.max_length if extra > 0: first_ind = random.randint(0,extra - 1) x = x[first_ind:first_ind+self.max_length] len_x = self.max_length return x, len_x def creat_noisy_data(self, x_clean, noise, SNR): sp_ener = torch.sum(x_clean**2) noi_ener = torch.sum(noise**2) a = (sp_ener/noi_ener)**0.5 * 10**(-SNR/20) x_noisy = x_clean + a * noise return x_noisy def prepare_noise(self, path, len_x): noise = self.load_sample(path) len_n = len(noise) if len_n < len_x: repeat = len_x // len_n + 1 noise = [noise for _ in range(repeat)] noise = np.concatenate(noise, axis=0) noise = self.crop_noise(noise, len_x) return noise def creat_target(self, clean_flnm, len_x): label_flnm = os.path.basename(clean_flnm).split("SPLIT")[0] + ".txt" with open(os.path.join(self.base_lbl,label_flnm), 'rb') as handle: framed_label = np.array(pickle.load( handle)) if self.is_post_process: framed_label = framed_label[None,...] framed_label = post_processing_VAD(framed_label, goal = 1, len_frame_ms = 20, sensitivity_ms = self.sens_ms).squeeze() label = np.repeat(framed_label, 320, axis=0) if label.shape[-1] > len_x: label = label[:len_x] return label, framed_label def __len__(self): return len(self.clean_paths) def __getitem__(self, index): # load to tensors and normalization x_clean = self.load_sample(os.path.join(self.base_clean_path, self.clean_paths[index])) x_clean, len_x = self.crop_audio(x_clean) x_clean = x_clean * np.random.uniform(0.7,1,1) noise = self.prepare_noise(os.path.join(self.base_noise_path, self.noise_paths[random.sample(range(self.len_noise), 1)[0]]), len_x) x_clean = torch.from_numpy(x_clean) noise = torch.from_numpy(noise) is_reverb = torch.rand(1) < self.t_reverb if is_reverb: x_clean = self.create_reverb(x_clean, os.path.join(self.base_rever_path, self.reverb_paths[random.sample(range(self.len_reverb), 1)[0]])) noise = self.create_reverb(noise, os.path.join(self.base_rever_path, self.reverb_paths[random.sample(range(self.len_reverb), 1)[0]])) n_o_n = random.randint(1,self.max_noise_n) if n_o_n == 2: noise_2 = self.prepare_noise(os.path.join(self.base_noise_path, self.noise_paths[random.sample(range(self.len_noise), 1)[0]]), len_x) noise_2 = torch.from_numpy(noise_2) if is_reverb: noise_2 = self.create_reverb(noise, os.path.join(self.base_rever_path, self.reverb_paths[random.sample(range(self.len_reverb), 1)[0]])) noise = noise + noise_2 snr = self.SNR_amount[random.sample(range(self.len_snr),1)[0]] x_noisy = self.creat_noisy_data(x_clean, noise, snr) target, framed_target = self.creat_target(self.clean_paths[index], len_x) target = torch.from_numpy(target) framed_target = torch.from_numpy(framed_target) return x_noisy, target, framed_target, is_reverb, n_o_n, snr def collate_fn(batch): inputs, targets, length_ratio = [], [], [] for noisy_input, target, framed_target, _, _, _ in batch: inputs.append(noisy_input) targets.append(target) framed_target.append(framed_target) length_ratio.append(len(noisy_input)) inputs = pad_sequence(inputs, batch_first=True, padding_value=0.0) targets = pad_sequence(targets, batch_first=True, padding_value=0.0) framed_target = pad_sequence(framed_target, batch_first=True, padding_value=0.0) length_ratio = torch.tensor(length_ratio, dtype=torch.long) / inputs.shape[1] return inputs, targets, framed_target, length_ratio # for reading and preparing dataset def audio_data_loader(base_clean_path, base_noise_path, base_rever_path, clean_paths, noise_paths, reverb_paths, sampling_rate, max_length, max_noise_n, t_reverb, min_snr, batch_size, num_workers, pin_memory, training ): dataset = Enhancement_DATASET(base_clean_path, base_noise_path, base_rever_path, clean_paths, noise_paths, reverb_paths, sampling_rate, max_length, max_noise_n, t_reverb, min_snr ) loader = DataLoader(dataset, batch_size = batch_size, shuffle = training, drop_last = True, collate_fn = collate_fn, num_workers = num_workers, pin_memory = pin_memory ) return loader