def main(_): initialize_globals() input_dir = './data/CommonVoice/pertubed_sets' output_dir = './results/randomly-initialized' tfv1.reset_default_graph() activations_common_voice_pertubed_sets(input_dir=input_dir, output_dir=output_dir, test_only=True, randomly_initialized=True) output_dir = './results' # Obtain activations for all sets without pruning of common voice test set tfv1.reset_default_graph() activations_common_voice_pertubed_sets(input_dir=input_dir, output_dir=output_dir) # Obtain activations for non-training sets with pruning of common voice test set tfv1.reset_default_graph() activations_peractivations_common_voice_pertubed_setstubed_sets( input_dir=input_dir, output_dir=output_dir, test_only=True, prune_percentage=.1, scores_file='./results/activations_combined.npy') # Obtain activations for non-training sets with pruning of common voice test set tfv1.reset_default_graph() activations_peractivations_common_voice_pertubed_setstubed_sets( input_dir=input_dir, output_dir=output_dir, test_only=True, random=True, prune_percentage=.1, scores_file='./results/activations_combined.npy') # Obtain activations for all sets without pruning of librispeech validation set tfv1.reset_default_graph() activations_libri_speech_test_set(input_dir=input_dir, output_dir=output_dir) # Obtain activations for non-training sets with pruning of librispeech validation set tfv1.reset_default_graph() activations_libri_speech_test_set( input_dir=input_dir, output_dir=output_dir, test_only=True, prune_percentage=.1, scores_file='./results/activations_combined.npy') # Obtain activations for non-training sets with random pruning of librispeech validation set tfv1.reset_default_graph() activations_libri_speech_test_set( input_dir=input_dir, output_dir=output_dir, test_only=True, random=True, prune_percentage=.1, scores_file='./results/activations_combined.npy')
def main(_): initialize_globals() if FLAGS.train or FLAGS.test: if len(FLAGS.worker_hosts) == 0: # Only one local task: this process (default case - no cluster) with tf.Graph().as_default(): train() if Config.is_chief: export() # Now do a final test epoch if FLAGS.test: with tf.Graph().as_default(): test() log_debug('Done.') else: # Create and start a server for the local task. server = tf.train.Server(Config.cluster, job_name=FLAGS.job_name, task_index=FLAGS.task_index) if FLAGS.job_name == 'ps': # We are a parameter server and therefore we just wait for all workers to finish # by waiting for their stop tokens. with tf.Session(server.target) as session: for worker in FLAGS.worker_hosts: log_debug('Waiting for stop token...') token = session.run( Config.done_dequeues[FLAGS.task_index]) if token < 0: log_debug( 'Got a kill switch token from worker %i.' % abs(token + 1)) break log_debug('Got a stop token from worker %i.' % token) log_debug('Session closed.') if FLAGS.test: test() elif FLAGS.job_name == 'worker': # We are a worker and therefore we have to do some work. # Assigns ops to the local worker by default. with tf.device( tf.train.replica_device_setter( worker_device=Config.worker_device, cluster=Config.cluster)): # Do the training train(server) log_debug('Server stopped.') # Are we the main process? if Config.is_chief: # Doing solo/post-processing work just on the main process... # Exporting the model if FLAGS.export_dir: export() if len(FLAGS.one_shot_infer): do_single_file_inference(FLAGS.one_shot_infer)
def main(_): initialize_globals() if FLAGS.train_files: tfv1.reset_default_graph() tfv1.set_random_seed(FLAGS.random_seed) train() if FLAGS.test_files: tfv1.reset_default_graph() test() if FLAGS.export_dir and not FLAGS.export_zip: tfv1.reset_default_graph() export() if FLAGS.export_zip: tfv1.reset_default_graph() FLAGS.export_tflite = True if os.listdir(FLAGS.export_dir): log_error('Directory {} is not empty, please fix this.'.format(FLAGS.export_dir)) sys.exit(1) export() package_zip() if FLAGS.one_shot_infer: tfv1.reset_default_graph() do_single_file_inference(FLAGS.one_shot_infer)
def total_inference(input_folder, output_folder, checkpoint_dir, layer_wanted, softmax_wanted, win_size_s, stride_size_s, fea_format, csv_format): initialize_globals() for root, dirs, files in os.walk(input_folder): nb = len(files) it = 0 # Iterate over files for filename in files: print(filename) if ((it + 1) % 100) == 0: print(it, 'on', nb) it += 1 if not filename.endswith('.wav'): continue else: full_name = os.path.join(root.lstrip('./'), filename) tf.reset_default_graph() do_single_file_inference(checkpoint_dir=checkpoint_dir, input_file_path='/' + full_name, layer_wanted=layer_wanted, win_size_s=win_size_s, stride_size_s=stride_size_s, save_folder=output_folder, save_filename=filename[:-4], softmax_wanted=softmax_wanted, fea_format=fea_format, csv_format=csv_format)
def main(_): initialize_globals() if not FLAGS.test_files: log_error('You need to specify what files to use for evaluation via ' 'the --test_files flag.') exit(1) global alphabet alphabet = Alphabet(FLAGS.alphabet_config_path) # sort examples by length, improves packing of batches and timesteps test_data = preprocess( FLAGS.test_files.split(','), FLAGS.test_batch_size, alphabet=alphabet, numcep=Config.n_input, numcontext=Config.n_context, hdf5_cache_path=FLAGS.hdf5_test_set).sort_values( by="features_len", ascending=False) from DeepSpeech import create_inference_graph graph = create_inference_graph(batch_size=FLAGS.test_batch_size, n_steps=-1) samples = evaluate(test_data, graph, alphabet) if FLAGS.test_output_file: # Save decoded tuples as JSON, converting NumPy floats to Python floats json.dump(samples, open(FLAGS.test_output_file, 'w'), default=lambda x: float(x))
def transcribe_file(audio_path, tlog_path): from DeepSpeech import create_model # pylint: disable=cyclic-import,import-outside-toplevel from util.checkpoints import load_or_init_graph initialize_globals() scorer = Scorer(FLAGS.lm_alpha, FLAGS.lm_beta, FLAGS.scorer_path, Config.alphabet) try: num_processes = cpu_count() except NotImplementedError: num_processes = 1 with AudioFile(audio_path, as_path=True) as wav_path: data_set = split_audio_file( wav_path, batch_size=FLAGS.batch_size, aggressiveness=FLAGS.vad_aggressiveness, outlier_duration_ms=FLAGS.outlier_duration_ms, outlier_batch_size=FLAGS.outlier_batch_size) iterator = tf.data.Iterator.from_structure( data_set.output_types, data_set.output_shapes, output_classes=data_set.output_classes) batch_time_start, batch_time_end, batch_x, batch_x_len = iterator.get_next( ) no_dropout = [None] * 6 logits, _ = create_model(batch_x=batch_x, seq_length=batch_x_len, dropout=no_dropout) transposed = tf.nn.softmax(tf.transpose(logits, [1, 0, 2])) tf.train.get_or_create_global_step() with tf.Session(config=Config.session_config) as session: if FLAGS.load == 'auto': method_order = ['best', 'last'] else: method_order = [FLAGS.load] load_or_init_graph(session, method_order) session.run(iterator.make_initializer(data_set)) transcripts = [] while True: try: starts, ends, batch_logits, batch_lengths = \ session.run([batch_time_start, batch_time_end, transposed, batch_x_len]) except tf.errors.OutOfRangeError: break decoded = ctc_beam_search_decoder_batch( batch_logits, batch_lengths, Config.alphabet, FLAGS.beam_width, num_processes=num_processes, scorer=scorer) decoded = list(d[0][1] for d in decoded) transcripts.extend(zip(starts, ends, decoded)) transcripts.sort(key=lambda t: t[0]) transcripts = [{ 'start': int(start), 'end': int(end), 'transcript': transcript } for start, end, transcript in transcripts] with open(tlog_path, 'w') as tlog_file: json.dump(transcripts, tlog_file, default=float)
def main(_): initialize_globals() if FLAGS.cmd != 'classify' and FLAGS.cmd != 'attack': print('Unsupport command, please check your cmd parameter') else: adv_ds = AdvDeepSpeech(FLAGS.model_path, FLAGS.input) if FLAGS.cmd == 'classify': adv_ds.classify2(FLAGS.input) else: adv_ds.attack(FLAGS.iteration)
def main(_): initialize_globals() # Evaluate on: # - files used for pruning (per set prune or total prune) # - original test set for model pertubed_sets = json.load(open('data/pertubed_input_sets_balanced.json')) train_sets = json.load(open('./results/set_ids_used.json')) common_voice_info = get_file_info('./data/common-voice-pertubed_sets.csv') file_info = [] for set in pertubed_sets: if str(set['set_id']) in train_sets: continue for item in set['set_items']: filename = item['path'][:-4] file_info.append(common_voice_info[filename]) print('{} test files found...'.format(len(file_info))) # Clean up characters in case they are in the transcript not_allowed = [',', '.', '!', '?', '"', '-', ':', ';'] for info in file_info: if any(c in info['transcript'] for c in not_allowed): for c in not_allowed: info['transcript'] = info['transcript'].replace(c, '') # Prune on all pertubed sets combined and evaluate on test set percents = [0, .05, .1, .2] print('Evaluating pruning on common voice test set') evaluation = {} for percent in percents: results = evaluate(scores_path='./results/activations_combined.npy', prune_percent=percent, evaluate_files=file_info) evaluation['{}'.format(percent)] = results print(results) json.dump(evaluation, open('./results/evaluations_all_pertubated_sets.json', 'w+')) # Prune and evaluate on original test set percents = [0, .1] print('Evaluating pruning on original test set') file_info = get_file_info('./data/librivox-test-clean.csv') evaluation = {} for percent in percents: results = evaluate(scores_path='./results/activations_combined.npy', prune_percent=percent, evaluate_files=file_info.values()) evaluation['{}'.format(percent)] = results print(results) json.dump(evaluation, open('./results/evaluations_original_test_set.json', 'w+'))
def main(_): initialize_globals() if FLAGS.train or FLAGS.test: if len(FLAGS.worker_hosts) == 0: # Only one local task: this process (default case - no cluster) with tf.Graph().as_default(): tf.set_random_seed(FLAGS.random_seed) train() # Now do a final test epoch if FLAGS.test: with tf.Graph().as_default(): test() log_debug('Done.') else: # Create and start a server for the local task. server = tf.train.Server(Config.cluster, job_name=FLAGS.job_name, task_index=FLAGS.task_index) if FLAGS.job_name == 'ps': # We are a parameter server and therefore we just wait for all workers to finish # by waiting for their stop tokens. with tf.Session(server.target) as session: for worker in FLAGS.worker_hosts: log_debug('Waiting for stop token...') token = session.run(Config.done_dequeues[FLAGS.task_index]) if token < 0: log_debug('Got a kill switch token from worker %i.' % abs(token + 1)) break log_debug('Got a stop token from worker %i.' % token) log_debug('Session closed.') if FLAGS.test: test() elif FLAGS.job_name == 'worker': # We are a worker and therefore we have to do some work. # Assigns ops to the local worker by default. with tf.device(tf.train.replica_device_setter( worker_device=Config.worker_device, cluster=Config.cluster)): # Do the training train(server) log_debug('Server stopped.') # Are we the main process? if Config.is_chief: # Doing solo/post-processing work just on the main process... # Exporting the model if FLAGS.export_dir: export() if len(FLAGS.one_shot_infer): do_single_file_inference(FLAGS.one_shot_infer)
def main(_): initialize_globals() if not FLAGS.test_files: log_error('You need to specify what files to use for evaluation via ' 'the --test_files flag.') exit(1) from DeepSpeech import create_model, try_loading # pylint: disable=cyclic-import samples = evaluate(FLAGS.test_files.split(','), create_model, try_loading) if FLAGS.test_output_file: # Save decoded tuples as JSON, converting NumPy floats to Python floats json.dump(samples, open(FLAGS.test_output_file, 'w'), default=float)
def main(_): initialize_globals() if not FLAGS.test_files: log_error('You need to specify what files to use for evaluation via ' 'the --test_files flag.') exit(1) from DeepSpeech import create_model, try_loading # pylint: disable=cyclic-import samples = evaluate(FLAGS.test_files.split(','), create_model, try_loading) if FLAGS.test_output_file: # Save decoded tuples as JSON, converting NumPy floats to Python floats json.dump(samples, open(FLAGS.test_output_file, 'w'), default=float)
def main(_): initialize_globals() evaluation_csv = './data/librivox-test-clean.csv' results_file = './results/evaluation_output.txt' scores_file = './results/final_imp_scores.npy' for prune_settings in [(0, False), (.05, False), (.05, True), (.1, False), (.1, True), (.15, False), (.15, True)]: evaluate_with_pruning(evaluation_csv, create_model, try_loading, prune_settings[0], random=prune_settings[1], scores_file=scores_file, result_file=results_file)
def main(_): initialize_globals() if not FLAGS.test_files: log_error('You need to specify what files to use for evaluation via ' 'the --test_files flag.') sys.exit(1) is_character_based = character_based() study = optuna.create_study() study.set_user_attr("is_character_based", is_character_based) study.optimize(objective, n_jobs=1, n_trials=FLAGS.n_trials) print('Best params: lm_alpha={} and lm_beta={} with WER={}'.format( study.best_params['lm_alpha'], study.best_params['lm_beta'], study.best_value))
def main(_): initialize_globals() if FLAGS.train: with tf.Graph().as_default(): tf.set_random_seed(FLAGS.random_seed) train() if FLAGS.test: with tf.Graph().as_default(): test() if FLAGS.export_dir: export() if len(FLAGS.one_shot_infer): do_single_file_inference(FLAGS.one_shot_infer)
def main(_): initialize_globals() if FLAGS.train_files: tfv1.reset_default_graph() tfv1.set_random_seed(FLAGS.random_seed) train() if FLAGS.test_files: tfv1.reset_default_graph() test() if FLAGS.export_dir: tfv1.reset_default_graph() export() if FLAGS.one_shot_infer: tfv1.reset_default_graph() do_single_file_inference(FLAGS.one_shot_infer)
def main(_): initialize_globals() if FLAGS.train or FLAGS.test: # Only one local task: this process (default case - no cluster) with tf.Graph().as_default(): tf.set_random_seed(FLAGS.random_seed) train() # Now do a final test epoch if FLAGS.test: with tf.Graph().as_default(): test() log_debug('Done.') # Are we the main process? if Config.is_chief: # Doing solo/post-processing work just on the main process... # Exporting the model if FLAGS.export_dir: export()
def main(_): initialize_globals() if not FLAGS.test_files: log_error('You need to specify what files to use for evaluation via ' 'the --test_files flag.') exit(1) #if FLAGS.embeddings_output_dir: # prefix = FLAGS.embeddings_output_dir # print('Prefix :', prefix) # #print('LAYER4 :', LAYER4) # EMBEDDINGS = prefix + 'embeddings/' # LAYER4 = EMBEDDINGS + 'layer4/' # LAYER5 = EMBEDDINGS + 'layer5/' # LAYER6 = EMBEDDINGS + 'layer6/' # c.TEXT = EMBEDDINGS + 'text/' # print('LAYER4 :', LAYER4) # sort examples by length, improves packing of batches and timesteps test_data = preprocess(FLAGS.test_files.split(','), FLAGS.test_batch_size, alphabet=Config.alphabet, numcep=Config.n_input, numcontext=Config.n_context, hdf5_cache_path=FLAGS.hdf5_test_set).sort_values( by="features_len", ascending=False) #print('test_data', test_data) #print(test_data.fname[1]) #return 1 #print(test_data[0].fname) print('Batch Size: ', FLAGS.test_batch_size) from DeepSpeech import create_inference_graph graph = create_inference_graph(batch_size=FLAGS.test_batch_size, n_steps=-1) samples = evaluate(test_data, graph) if FLAGS.test_output_file: # Save decoded tuples as JSON, converting NumPy floats to Python floats json.dump(samples, open(FLAGS.test_output_file, 'w'), default=lambda x: float(x))
def load_graph(frozen_graph_filename=GRAPH_PB_PATH): # We load the protobuf file from the disk and parse it to retrieve the # unserialized graph_def with tf.gfile.GFile(frozen_graph_filename, "rb") as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) return graph_def if __name__ == '__main__': # Initialize Globals. create_flags() initialize_globals() # Load pretrained model. graph_def = load_graph() with tf.Graph().as_default() as graph: # The name var will prefix every op/nodes in your graph # Since we load everything in a new graph, this is not needed tf.import_graph_def(graph_def, name="prefix") # Open tf.Session. with tf.Session(graph=graph) as sess: # Extract graph node names. tf.import_graph_def(graph_def, name='') graph_nodes = [n for n in graph_def.node] names = []
def main(_): initialize_globals() if FLAGS.train or FLAGS.test: if len(FLAGS.worker_hosts) == 0: # Only one local task: this process (default case - no cluster) #with tf.Graph().as_default(): #train() #if Config.is_chief: # export() # Now do a final test epoch if FLAGS.test: print("$$$$$$$$$ Testing on entire test dataset $$$$$$$$$$") ckpt_files = [ f for f in sorted(os.listdir(FLAGS.checkpoint_dir)) if os.path.isfile(os.path.join(FLAGS.checkpoint_dir, f)) and '.meta' in f ] for ckpt_file in ckpt_files: print("************* Testing on ckpt file: " + ckpt_file + " ***************") with tf.Graph().as_default(): test(ckpt_file.replace(".meta", ""), FLAGS.test_files) log_debug('Done.') for test_file in FLAGS.test_files.split(","): print("$$$$$$$$$ Testing on " + test_file + " dataset $$$$$$$$$$") ckpt_files = [ f for f in sorted(os.listdir(FLAGS.checkpoint_dir)) if os.path.isfile(os.path.join(FLAGS.checkpoint_dir, f)) and '.meta' in f ] for ckpt_file in ckpt_files: print("************* Testing on ckpt file: " + ckpt_file + " ***************") with tf.Graph().as_default(): test(ckpt_file.replace(".meta", ""), test_file) log_debug('Done.') else: # Create and start a server for the local task. server = tf.train.Server(Config.cluster, job_name=FLAGS.job_name, task_index=FLAGS.task_index) if FLAGS.job_name == 'ps': # We are a parameter server and therefore we just wait for all workers to finish # by waiting for their stop tokens. with tf.Session(server.target) as session: for worker in FLAGS.worker_hosts: log_debug('Waiting for stop token...') token = session.run( Config.done_dequeues[FLAGS.task_index]) if token < 0: log_debug( 'Got a kill switch token from worker %i.' % abs(token + 1)) break log_debug('Got a stop token from worker %i.' % token) log_debug('Session closed.') if FLAGS.test: test() elif FLAGS.job_name == 'worker': # We are a worker and therefore we have to do some work. # Assigns ops to the local worker by default. with tf.device( tf.train.replica_device_setter( worker_device=Config.worker_device, cluster=Config.cluster)): # Do the training train(server) log_debug('Server stopped.') # Are we the main process? #if Config.is_chief: # Doing solo/post-processing work just on the main process... # Exporting the model #if FLAGS.export_dir: #export() if len(FLAGS.one_shot_infer): do_single_file_inference(FLAGS.one_shot_infer)