def generate_noise_data(path): with open(path, 'rb') as f: audio_list = pickle.load(f) print('read pkl from ', f) spec_list = [] record_count = 0 for i, audio_name in enumerate(audio_list): spec, y = process_stft(path_join(wave_noise_dir, audio_name)) if spec.shape[0] >= config.max_sequence_length: spec_list.extend( split_spectrogram(spec, config.max_sequence_length)) else: spec_list.append( expand_spectrogram(spec, config.max_sequence_length)) if len(spec_list) >= config.tfrecord_size: fname = 'noise' + increment_id(record_count, 5) + '.tfrecords' temp = spec_list[:config.tfrecord_size] spec_list = spec_list[config.tfrecord_size:] ex_list = [make_noise_example(spec) for spec in temp] writer = tf.python_io.TFRecordWriter( path_join(save_noise_dir, fname)) for ex in ex_list: writer.write(ex.SerializeToString()) writer.close() record_count += 1 print(fname, 'created') print('save in %s' % save_noise_dir)
def generate_noise_data(path): with open(path, 'rb') as f: audio_list = pickle.load(f) print('read pkl from ', f) spec_list = [] counter = 0 record_count = 0 for i, audio_name in enumerate(audio_list): spec, y = process_stft(path_join(wave_noise_dir, audio_name)) spec_list.append(spec) counter += 1 if counter == config.tfrecord_size: spec_list = [ expand_spectrogram(s, config.max_sequence_length) for s in spec_list ] fname = 'noise' + increment_id(record_count, 5) + '.tfrecords' ex_list = [make_noise_example(spec) for spec in spec_list] writer = tf.python_io.TFRecordWriter( path_join(save_noise_dir, fname)) for ex in ex_list: writer.write(ex.SerializeToString()) writer.close() record_count += 1 counter = 0 spec_list.clear() print(fname, 'created') print('save in %s' % save_noise_dir)
def generate_valid_data(path): with open(path, 'rb') as f: wav_list = pickle.load(f) print('read pkl from %s' % f) # each record should be (file.wav,((st,end),(st,end).....))) file_list = [i[0] for i in wav_list] label_list = [i[1] for i in wav_list] tuple_list = [] counter = 0 record_count = 0 for i, audio_name in enumerate(file_list): # print(audio_name) # print(label_list[i]) spec, seq_len, labels = make_record( path_join(wave_valid_dir, audio_name), label_list[i]) counter += 1 tuple_list.append((spec, labels, seq_len)) if counter == config.tfrecord_size: tuple_list = batch_padding(tuple_list) fname = 'data' + increment_id(record_count, 5) + '.tfrecords' ex_list = [make_example(spec, seq_len, labels) for spec, labels, seq_len in tuple_list] writer = tf.python_io.TFRecordWriter( path_join(save_valid_dir, fname)) for ex in ex_list: writer.write(ex.SerializeToString()) writer.close() record_count += 1 counter = 0 tuple_list.clear() print(fname, 'created') print('save in %s' % save_valid_dir)
def build_graph(self, DeployModel): check_dir(self.config.graph_path) config_path = path_join(self.config.graph_path, 'config.pkl') graph_path = path_join(self.config.graph_path, self.config.graph_name) import pickle pickle.dump(self.config, open(config_path, 'wb')) with tf.Graph().as_default(), tf.Session(config=tf.ConfigProto( allow_soft_placement=True)) as session: with tf.variable_scope("model"): model = DeployModel(config=config) print('Graph build finished') variable_names = [n.name for n in tf.get_default_graph().as_graph_def().node] for n in variable_names: print(n) saver = tf.train.Saver() saver.restore(session, save_path=path_join(self.config.model_path, 'latest.ckpt')) print("model restored from %s" % config.model_path) frozen_graph_def = graph_util.convert_variables_to_constants( session, session.graph.as_graph_def(), ['model/inputX', 'model/rnn_initial_states', 'model/rnn_states', 'model/softmax', 'model/logit']) tf.train.write_graph( frozen_graph_def, self.config.graph_path, self.config.graph_name, as_text=False, ) try: tf.import_graph_def(frozen_graph_def, name="") except Exception as e: print("!!!!Import graph meet error: ", e) exit() print('graph saved in %s' % graph_path) print("====octbit graph====") rewriter = GraphRewriter(frozen_graph_def, mode="octbit") octbit_graph = rewriter.rewrite( ['model/inputX', 'model/rnn_initial_states', 'model/rnn_states', 'model/softmax', 'model/logit']) try: tf.import_graph_def(octbit_graph, name="") except Exception as e: print("!!!!Import octbit graph meet error: ", e) exit() tf.train.write_graph( octbit_graph, self.config.graph_path, self.config.graph_name[:-3] + '_octbit.pb', as_text=False, )
def handler_stop_signals(signum, frame): global run run = False if not DEBUG: print( 'training shut down, total setp %s, the model will be save in %s' % ( step, self.config.save_path)) saver.save(sess, save_path=( path_join(self.config.save_path, 'latest.ckpt'))) print('best accuracy', best_accuracy) sys.exit(0)
def handler_stop_signals(signum, frame): global run run = False if not DEBUG: print( 'training shut down, total setp %s, the model will be save in %s' % ( step, self.config.model_path)) saver.save(sess, save_path=( path_join(self.config.model_path, 'latest.ckpt'))) print('best miss rate:%f\tbest false rate %f' % ( best_miss, best_false)) sys.exit(0)
def __init__(self, config, train_dir, valid_dir, noise_dir, mode='train'): self.config = config # freq size of linear spectrogram self.last_dim = 1 + config.fft_size // 2 self.mel_basis = librosa.filters.mel( sr=config.samplerate, n_fft=config.fft_size, fmin=config.fmin, fmax=config.fmax, n_mels=config.freq_size).T self.mel_basis = tf.constant(value=self.mel_basis, dtype=tf.float32) self.mel_basis = tf.tile(tf.expand_dims(self.mel_basis, 0), [config.batch_size, 1, 1]) if mode == 'train': self.train_filename = glob(path_join(train_dir, '*.tfrecords')) # self.train_filename = sorted(self.train_filename) self.train_file_size = len(self.train_filename) if self.train_file_size == 0: raise Exception('train tfrecords not found') self.train_reader = tf.TFRecordReader(name='train_reader') self.epoch = self.epochs_completed print('file size', self.train_file_size) if config.use_bg_noise: self.noise_filename = glob(path_join(noise_dir, '*.tfrecords')) self.noise_reader = tf.TFRecordReader(name='noise_reader') if len(self.noise_filename) == 0: raise Exception( 'noise tfrecords not found. Or disable noise option') self.valid_filename = glob(path_join(valid_dir, '*.tfrecords')) self.valid_filename = sorted(self.valid_filename) self.valid_file_size = len(self.valid_filename) if self.valid_file_size == 0: raise Exception('valid tfrecords not found') self.valid_reader = tf.TFRecordReader(name='valid_reader') self.validation_size = len(self.valid_filename) * config.tfrecord_size print('validation size', self.validation_size)
def generate(path): noise, _ = librosa.load(noise_file) with open(path, 'rb') as f: wav_list = pickle.load(f) print('read pkl from %s' % f) # each record should be (file.wav,((st,end),(st,end).....))) file_list = [i[0] for i in wav_list] for f in file_list: y, _ = librosa.load(path_join(wave_valid_dir, f), sr=config.samplerate) wave_db = compute_db(y) start = random.randint(0, len(noise) - len(y)) temp = noise[start:start + len(y)] noise_db = compute_db(temp) factor = wave_db - noise_db + db_decay factor = 10**(factor / 10) temp *= factor y += temp librosa.output.write_wav(path_join(save_valid_dir, f), y, sr=config.samplerate)
def generate_trainning_data(path): with open(path, 'rb') as f: wav_list = pickle.load(f) print('read pkl from %s' % f) audio_list = [i[0] for i in wav_list] label_list = [i[1] for i in wav_list] text_list = [i[2] for i in wav_list] assert len(audio_list) == len(text_list) tuple_list = [] counter = 0 record_count = 0 for i, audio_name in enumerate(audio_list): spec, seq_len, label_values, label_indices, label_shape = make_record( path_join(wave_train_dir, audio_name), label_list[i]) # print(text_list[i]) # print(label_values) if spec is not None: counter += 1 tuple_list.append( (spec, seq_len, label_values, label_indices, label_shape)) if counter == config.tfrecord_size: tuple_list = batch_padding_trainning(tuple_list) fname = 'data' + increment_id(record_count, 5) + '.tfrecords' ex_list = [ make_trainning_example(spec, seq_len, label_values, label_indices, label_shape) for spec, seq_len, label_values, label_indices, label_shape in tuple_list ] writer = tf.python_io.TFRecordWriter( path_join(save_train_dir, fname)) for ex in ex_list: writer.write(ex.SerializeToString()) writer.close() record_count += 1 counter = 0 tuple_list.clear() print(fname, 'created') print('save in %s' % save_train_dir)
def generate_valid_data(pkl_path): with open(pkl_path, 'rb') as f: wav_list = pickle.load(f) print('read pkl from %s' % f) audio_list = [i[0] for i in wav_list] correctness_list = [i[1] for i in wav_list] label_list = [i[2] for i in wav_list] assert len(audio_list) == len(correctness_list) tuple_list = [] counter = 0 record_count = 0 for audio_name, correctness, label in zip(audio_list, correctness_list, label_list): spectrogram, wave = process_stft(path_join(wave_valid_dir, audio_name)) seq_len = spectrogram.shape[0] label_values, _, _ = convert_label(label) tuple_list.append( (spectrogram, seq_len, correctness, label_values, audio_name)) counter += 1 if counter == config.tfrecord_size: tuple_list = batch_padding_valid(tuple_list) fname = 'valid' + increment_id(record_count, 5) + '.tfrecords' ex_list = [ make_valid_example(spec, seq_len, correctness, label_values, audio_name) for spec, seq_len, correctness, label_values, audio_name in tuple_list ] writer = tf.python_io.TFRecordWriter( path_join(save_valid_dir, fname)) for ex in ex_list: writer.write(ex.SerializeToString()) writer.close() record_count += 1 counter = 0 tuple_list.clear() print(fname, 'created') print('save in %s' % save_valid_dir)
def __init__(self, config): self.graph_def = tf.GraphDef() self.config = config with open(path_join(config.graph_path, config.graph_name), 'rb') as f: # print (f.read()) self.graph_def.ParseFromString(f.read()) # for node in self.graph_def.node: # print(node.name) self.graph = tf.Graph() with self.graph.as_default(): tf.import_graph_def(self.graph_def, name="") nodes = [node.name for node in self.graph.get_operations()] for i in nodes: if 'nn' in i: print(i) self.sess = tf.Session(graph=self.graph)
def run(self, TrainingModel): graph = tf.Graph() with graph.as_default(), tf.Session() as sess: self.data = read_dataset(self.config) if config.mode == 'train': print('building training model....') with tf.variable_scope("model"): self.train_model = TrainingModel(self.config, self.data.batch_input_queue(), is_train=True) self.train_model.config.show() print('building valid model....') with tf.variable_scope("model", reuse=True): self.valid_model = TrainingModel(self.config, self.data.valid_queue(), is_train=False) else: with tf.variable_scope("model", reuse=False): self.valid_model = TrainingModel(self.config, self.data.valid_queue(), is_train=False) saver = tf.train.Saver() # restore from stored models files = glob(path_join(self.config.model_path, '*.ckpt.*')) if len(files) > 0: saver.restore(sess, path_join(self.config.model_path, self.config.model_name)) print(('Model restored from:' + self.config.model_path)) else: print("Model doesn't exist.\nInitializing........") sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) tf.Graph.finalize(graph) st_time = time.time() if os.path.exists(path_join(self.config.model_path, 'best.pkl')): with open(path_join(self.config.model_path, 'best.pkl'), 'rb') as f: best_miss, best_false = pickle.load(f) print('best miss', best_miss, 'best false', best_false) else: print('best not exist') check_dir(self.config.model_path) if self.config.mode == 'train': best_miss = 1 best_false = 1 accu_loss = 0 epoch_step = config.tfrecord_size * self.data.train_file_size // config.batch_size if self.config.reset_global: sess.run(self.train_model.reset_global_step) def handler_stop_signals(signum, frame): global run run = False if not DEBUG: print( 'training shut down, total setp %s, the model will be save in %s' % ( step, self.config.model_path)) saver.save(sess, save_path=( path_join(self.config.model_path, 'latest.ckpt'))) print('best miss rate:%f\tbest false rate %f' % ( best_miss, best_false)) sys.exit(0) signal.signal(signal.SIGINT, handler_stop_signals) signal.signal(signal.SIGTERM, handler_stop_signals) best_list = [] best_threshold = 0.08 best_count = 0 # (miss,false,step,best_count) last_time = time.time() try: sess.run([self.data.noise_stage_op, self.data.noise_filequeue_enqueue_op, self.train_model.stage_op, self.train_model.input_filequeue_enqueue_op, self.valid_model.stage_op, self.valid_model.input_filequeue_enqueue_op]) va = tf.trainable_variables() for i in va: print(i.name) while self.epoch < self.config.max_epoch: _, _, _, _, _, l, lr, step, grads = sess.run( [self.train_model.train_op, self.data.noise_stage_op, self.data.noise_filequeue_enqueue_op, self.train_model.stage_op, self.train_model.input_filequeue_enqueue_op, self.train_model.loss, self.train_model.learning_rate, self.train_model.global_step, self.train_model.grads ]) epoch = step // epoch_step accu_loss += l if epoch > self.epoch: self.epoch = epoch print('accumulated loss', accu_loss) saver.save(sess, save_path=( path_join(self.config.model_path, 'latest.ckpt'))) print('latest.ckpt save in %s' % ( path_join(self.config.model_path, 'latest.ckpt'))) accu_loss = 0 if step % config.valid_step == 0: print('epoch time ', (time.time() - last_time) / 60) last_time = time.time() miss_count = 0 false_count = 0 target_count = 0 wer = 0 valid_batch = self.data.valid_file_size * config.tfrecord_size // config.batch_size text = "" for i in range(valid_batch): softmax, correctness, labels, _, _ = sess.run( [self.valid_model.softmax, self.valid_model.correctness, self.valid_model.labels, self.valid_model.stage_op, self.valid_model.input_filequeue_enqueue_op]) np.set_printoptions(precision=4, threshold=np.inf, suppress=True) decode_output = [ctc_decode(s) for s in softmax] for i in decode_output: text += str(i) + '\n' text += str(labels) + '\n' text += '=' * 20 + '\n' result = [ctc_predict(seq, config.label_seqs) for seq in decode_output] miss, target, false_accept = evaluate( result, correctness.tolist()) miss_count += miss target_count += target false_count += false_accept wer += self.wer_cal.cal_batch_wer(labels, decode_output).sum() # print(miss_count, false_count) with open('./valid.txt', 'w') as f: f.write(text) miss_rate = miss_count / target_count false_accept_rate = false_count / ( self.data.validation_size - target_count) print('--------------------------------') print('epoch %d' % self.epoch) print('training loss:' + str(l)) print('learning rate:', lr, 'global step', step) print('miss rate:' + str(miss_rate)) print('flase_accept_rate:' + str(false_accept_rate)) print(miss_count, '/', target_count) print('wer', wer / self.data.validation_size) if miss_rate + false_accept_rate < best_miss + best_false: best_miss = miss_rate best_false = false_accept_rate saver.save(sess, save_path=(path_join( self.config.model_path, 'best.ckpt'))) with open(path_join( self.config.model_path, 'best.pkl'), 'wb') as f: best_tuple = (best_miss, best_false) pickle.dump(best_tuple, f) if miss_rate + false_accept_rate < best_threshold: best_count += 1 print('best_count', best_count) best_list.append((miss_rate, false_accept_rate, step, best_count)) saver.save(sess, save_path=(path_join( self.config.model_path, 'best' + str( best_count) + '.ckpt'))) print( 'training finished, total epoch %d, the model will be save in %s' % ( self.epoch, self.config.model_path)) saver.save(sess, save_path=( path_join(self.config.model_path, 'latest.ckpt'))) print('best miss rate:%f\tbest false rate"%f' % ( best_miss, best_false)) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') except Exception as e: print(e) traceback.print_exc() finally: with open('best_list.pkl', 'wb') as f: pickle.dump(best_list, f) print('total time:%f hours' % ( (time.time() - st_time) / 3600)) # When done, ask the threads to stop. else: with open( config.rawdata_path + 'valid/' + "ctc_valid.pkl.sorted", 'rb') as f: pkl = pickle.load(f) miss_count = 0 false_count = 0 target_count = 0 valid_batch = self.data.valid_file_size * config.tfrecord_size // config.batch_size for i in range(valid_batch): # if i > 7: # break ind = 14 softmax, ctc_input, correctness, labels, _, _ = sess.run( [self.valid_model.softmax, self.valid_model.nn_outputs, self.valid_model.correctness, self.valid_model.labels, self.valid_model.stage_op, self.valid_model.input_filequeue_enqueue_op]) np.set_printoptions(precision=4, threshold=np.inf, suppress=True) correctness = correctness.tolist() decode_output = [ctc_decode(s) for s in softmax] result = [ctc_predict(seq, config.label_seqs) for seq in decode_output] for k, r in enumerate(result): if r != correctness[k]: name = pkl[i * config.batch_size + k][0] print("scp [email protected]:/ssd/keyword_raw/valid/%s ./"%name) # print(pkl[i * config.batch_size + k]) # print(decode_output[k]) # print(labels[k]) with open('logits.txt', 'w') as f: f.write(str(ctc_input[k])) miss, target, false_accept = evaluate( result, correctness) miss_count += miss target_count += target false_count += false_accept print('--------------------------------') print('miss rate: %d/%d' % (miss_count, target_count)) print('flase_accept_rate: %d/%d' % ( false_count, self.data.validation_size - target_count))
def run(self, TrainingModel): graph = tf.Graph() with graph.as_default(), tf.Session() as sess: self.data = read_dataset(self.config) if config.mode == 'train': print('building training model....') with tf.variable_scope("model"): self.train_model = TrainingModel(self.config, self.data.batch_input_queue(), is_train=True) self.train_model.config.show() print('building valid model....') with tf.variable_scope("model", reuse=True): self.valid_model = TrainingModel(self.config, self.data.valid_queue(), is_train=False) else: with tf.variable_scope("model", reuse=False): self.valid_model = TrainingModel(self.config, self.data.valid_queue(), is_train=False) saver = tf.train.Saver() # restore from stored models files = glob(path_join(self.config.model_path, '*.ckpt.*')) if len(files) > 0: saver.restore(sess, path_join(self.config.model_path, self.config.model_name)) print(('Model restored from:' + self.config.model_path)) else: print("Model doesn't exist.\nInitializing........") sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) tf.Graph.finalize(graph) best_accuracy = 1 accu_loss = 0 st_time = time.time() epoch_step = config.tfrecord_size * self.data.train_file_size // config.batch_size if os.path.exists(path_join(self.config.save_path, 'best.pkl')): with open(path_join(self.config.save_path, 'best.pkl'), 'rb') as f: best_accuracy = pickle.load(f) print('best accuracy', best_accuracy) else: print('best not exist') check_dir(self.config.save_path) if self.config.mode == 'train': if self.config.reset_global: sess.run(self.train_model.reset_global_step) def handler_stop_signals(signum, frame): global run run = False if not DEBUG: print( 'training shut down, total setp %s, the model will be save in %s' % ( step, self.config.save_path)) saver.save(sess, save_path=( path_join(self.config.save_path, 'latest.ckpt'))) print('best accuracy', best_accuracy) sys.exit(0) signal.signal(signal.SIGINT, handler_stop_signals) signal.signal(signal.SIGTERM, handler_stop_signals) best_list = [] best_threshold = 0.1 best_count = 0 # (miss,false,step,best_count) last_time = time.time() try: sess.run([self.data.noise_stage_op, self.data.noise_filequeue_enqueue_op, self.train_model.stage_op, self.train_model.input_filequeue_enqueue_op, self.valid_model.stage_op, self.valid_model.input_filequeue_enqueue_op]) va = tf.trainable_variables() for i in va: print(i.name) while self.epoch < self.config.max_epoch: _, _, _, _, _, l, lr, step, grads, vs = sess.run( [self.train_model.train_op, self.data.noise_stage_op, self.data.noise_filequeue_enqueue_op, self.train_model.stage_op, self.train_model.input_filequeue_enqueue_op, self.train_model.loss, self.train_model.learning_rate, self.train_model.global_step, self.train_model.grads, self.train_model.vs ]) # print('-'*30) # for i in vs: # print(i.sum()) # print('grads',len(grads)) # print('='*30) # for g in grads: # print(g.sum()) epoch = step // epoch_step accu_loss += l if epoch > self.epoch: self.epoch = epoch print('accumulated loss', accu_loss) saver.save(sess, save_path=( path_join(self.config.save_path, 'latest.ckpt'))) print('latest.ckpt save in %s' % ( path_join(self.config.save_path, 'latest.ckpt'))) accu_loss = 0 if step % config.valid_step == 2: print('epoch time ', (time.time() - last_time) / 60) last_time = time.time() total_speech = 0 total_silence = 0 total_miss = 0 total_false = 0 valid_batch = self.data.valid_file_size * config.tfrecord_size // config.batch_size text = "" for i in range(valid_batch): soft, labels, seqlen, _, _ = sess.run( [ self.valid_model.softmax, self.valid_model.labels, self.valid_model.seqLengths, self.valid_model.stage_op, self.valid_model.input_filequeue_enqueue_op]) np.set_printoptions(precision=4, threshold=np.inf, suppress=True) # print('-----------------') # # print(labels[0]) # print(names[0].decode()) # print(self.valid_set[i * config.batch_size]) # for i in names: # print(i.decode()) # print(softmax.shape) # for i, j in zip(soft, labels): # print(np.concatenate((i, j), 1)) # # for i in range(len(soft)): # soft[i][seqlen[i]:] = 0 logits = posterior_predict(soft, config.thres) target_speech, target_silence, miss, false_trigger = frame_accurcacy( logits, labels, seqlen) total_speech += target_speech total_silence += target_silence total_miss += miss total_false += false_trigger miss_rate = round(total_miss / total_speech, 4) false_rate = round(total_false / total_silence, 4) print('--------------------------------') print('epoch %d' % self.epoch) print('training loss:' + str(l)) print('learning rate:', lr, 'global step', step) print('miss rate:' + str(miss_rate)) print('false rate: ' + str(false_rate)) if miss_rate + false_trigger < best_accuracy: best_accuracy = miss_rate + false_trigger saver.save(sess, save_path=(path_join( self.config.save_path, 'best.ckpt'))) with open(path_join( self.config.save_path, 'best.pkl'), 'wb') as f: best_tuple = (miss_rate, false_rate) pickle.dump(best_tuple, f) if miss_rate + false_trigger < best_threshold: best_count += 1 print('best_count', best_count) best_list.append( (miss_rate, false_trigger, step, best_count)) saver.save(sess, save_path=(path_join( self.config.save_path, 'best' + str( best_count) + '.ckpt'))) print( 'training finished, total epoch %d, the model will be save in %s' % ( self.epoch, self.config.save_path)) saver.save(sess, save_path=( path_join(self.config.save_path, 'latest.ckpt'))) print('best accuracy:%f' % (best_accuracy)) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') except Exception as e: print(e) traceback.print_exc() finally: with open('best_list.pkl', 'wb') as f: pickle.dump(best_list, f) print('total time:%f hours' % ( (time.time() - st_time) / 3600)) # When done, ask the threads to stop. else: total = 0 wrong = 0 valid_batch = self.data.valid_file_size * config.tfrecord_size // config.batch_size for i in range(valid_batch): # if i > 7: # break ind = 14 logits, labels, _, _ = sess.run( [self.valid_model.outputs, self.valid_model.labels, self.valid_model.stage_op, self.valid_model.input_filequeue_enqueue_op]) np.set_printoptions(precision=4, threshold=np.inf, suppress=True) total_count, wrong_count = frame_accurcacy( logits, labels) total += total_count wrong += wrong_count accruracy = 1 - wrong / wrong # miss_rate = miss_count / target_count # false_accept_rate = false_count / total_count print('--------------------------------') print('accurcay: %f' % (accruracy))
wave_valid_dir = config.rawdata_path + 'train/' save_valid_dir = config.rawdata_path + 'valid/vad/' check_dir(save_valid_dir) def generate(path): noise, _ = librosa.load(noise_file) with open(path, 'rb') as f: wav_list = pickle.load(f) print('read pkl from %s' % f) # each record should be (file.wav,((st,end),(st,end).....))) file_list = [i[0] for i in wav_list] for f in file_list: y, _ = librosa.load(path_join(wave_valid_dir, f), sr=config.samplerate) wave_db = compute_db(y) start = random.randint(0, len(noise) - len(y)) temp = noise[start:start + len(y)] noise_db = compute_db(temp) factor = wave_db - noise_db + db_decay factor = 10**(factor / 10) temp *= factor y += temp librosa.output.write_wav(path_join(save_valid_dir, f), y, sr=config.samplerate) generate(path_join(config.rawdata_path, 'valid/vad_valid.pkl'))