def run(experiment_id, restore_path, config_file, bit, unquant_layers): if config_file is None and experiment_id is None: raise Exception("config_file or experiment_id are required") if experiment_id: environment.init(experiment_id) config = config_util.load_from_experiment() if config_file: config = config_util.merge(config, config_util.load(config_file)) if restore_path is None: restore_file = executor.search_restore_filename( environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) if not os.path.exists("{}.index".format(restore_path)): raise Exception( "restore file {} dont exists.".format(restore_path)) else: experiment_id = "profile" environment.init(experiment_id) config = config_util.load(config_file) executor.init_logging(config) config_util.display(config) _profile(config, restore_path, bit, unquant_layers)
def run_server(server_info, experiment_id, config_file, restore_path): environment.init(experiment_id) if config_file is None: config = config_util.load_from_experiment() else: config = config_util.merge(config, config_util.load(config_file)) if restore_path is None: restore_file = search_restore_filename(environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) inference_model = Inference(config, restore_path) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(server_info) s.listen(32) print("boot: {}:{}".format(*server_info)) while True: client_conn, client_addr = s.accept() print("\033[Kfrom: {}:{}".format(*client_addr), end="\r") try: th = threading.Thread(target=receive_and_send, args=(client_conn, inference_model), daemon=True) th.start() # th.join() # receive_and_send(client_conn, inference_model) except BrokenPipeError: print("Send data aborted!") pass
def get_export_directory(experiment_id, restore_path): """Return output dir of export""" config = config_util.load_from_experiment() if restore_path is None: restore_file = executor.search_restore_filename( environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) print("Restore from {}".format(restore_path)) if not os.path.exists("{}.index".format(restore_path)): raise Exception("restore file {} dont exists.".format(restore_path)) export_dir = os.path.join(environment.EXPERIMENT_DIR, "export") export_dir = os.path.join(export_dir, os.path.basename(restore_path)) export_dir = os.path.join( export_dir, "{}x{}".format(config.IMAGE_SIZE[0], config.IMAGE_SIZE[1])) return export_dir
def run(input_dir, output_dir, experiment_id, config_file, restore_path, save_images): environment.init(experiment_id) config = config_util.load_from_experiment() if config_file: config = config_util.merge(config, config_util.load(config_file)) if not os.path.isdir(input_dir): raise Exception("Input directory {} does not exist.".format(input_dir)) if restore_path is None: restore_file = search_restore_filename(environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) print("Restore from {}".format(restore_path)) if not os.path.exists("{}.index".format(restore_path)): raise Exception("restore file {} dont exists.".format(restore_path)) print("---- start predict ----") _run(input_dir, output_dir, config, restore_path, save_images) print("---- end predict ----")
def evaluate(config, restore_path): if restore_path is None: restore_file = executor.search_restore_filename( environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) if not os.path.exists("{}.index".format(restore_path)): raise Exception("restore file {} dont exists.".format(restore_path)) print("restore_path:", restore_path) DatasetClass = config.DATASET_CLASS ModelClass = config.NETWORK_CLASS network_kwargs = {key.lower(): val for key, val in config.NETWORK.items()} if "test" in DatasetClass.available_subsets: subset = "test" else: subset = "validation" validation_dataset = setup_dataset(config, subset, seed=0) graph = tf.Graph() with graph.as_default(): if ModelClass.__module__.startswith("lmnet.networks.object_detection"): model = ModelClass( classes=validation_dataset.classes, num_max_boxes=validation_dataset.num_max_boxes, is_debug=config.IS_DEBUG, **network_kwargs, ) else: model = ModelClass( classes=validation_dataset.classes, is_debug=config.IS_DEBUG, **network_kwargs, ) global_step = tf.Variable(0, name="global_step", trainable=False) is_training = tf.constant(False, name="is_training") images_placeholder, labels_placeholder = model.placeholders() output = model.inference(images_placeholder, is_training) metrics_ops_dict, metrics_update_op = model.metrics( output, labels_placeholder) model.summary(output, labels_placeholder) summary_op = tf.summary.merge_all() metrics_summary_op, metrics_placeholders = executor.prepare_metrics( metrics_ops_dict) init_op = tf.global_variables_initializer() reset_metrics_op = tf.local_variables_initializer() saver = tf.train.Saver(max_to_keep=None) session_config = None # tf.ConfigProto(log_device_placement=True) sess = tf.Session(graph=graph, config=session_config) sess.run([init_op, reset_metrics_op]) validation_writer = tf.summary.FileWriter(environment.TENSORBOARD_DIR + "/evaluate") saver.restore(sess, restore_path) last_step = sess.run(global_step) # init metrics values test_step_size = int( math.ceil(validation_dataset.num_per_epoch / config.BATCH_SIZE)) print("test_step_size", test_step_size) for test_step in range(test_step_size): print("test_step", test_step) images, labels = validation_dataset.feed() feed_dict = { images_placeholder: images, labels_placeholder: labels, } # Summarize at only last step. if test_step == test_step_size - 1: summary, _ = sess.run([summary_op, metrics_update_op], feed_dict=feed_dict) validation_writer.add_summary(summary, last_step) else: sess.run([metrics_update_op], feed_dict=feed_dict) metrics_values = sess.run(list(metrics_ops_dict.values())) metrics_feed_dict = { placeholder: value for placeholder, value in zip(metrics_placeholders, metrics_values) } metrics_summary, = sess.run( [metrics_summary_op], feed_dict=metrics_feed_dict, ) validation_writer.add_summary(metrics_summary, last_step)
def _export(config, restore_path, image_path): if restore_path is None: restore_file = executor.search_restore_filename( environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) print("Restore from {}".format(restore_path)) if not os.path.exists("{}.index".format(restore_path)): raise Exception("restore file {} dont exists.".format(restore_path)) output_root_dir = os.path.join(environment.EXPERIMENT_DIR, "export") output_root_dir = os.path.join(output_root_dir, os.path.basename(restore_path)) if not os.path.exists(output_root_dir): os.makedirs(output_root_dir) graph = tf.Graph() ModelClass = config.NETWORK_CLASS network_kwargs = dict( (key.lower(), val) for key, val in config.NETWORK.items()) with graph.as_default(): model = ModelClass( classes=config.CLASSES, is_debug=config.IS_DEBUG, **network_kwargs, ) is_training = tf.constant(False, name="is_training") images_placeholder, _ = model.placeholders() model.inference(images_placeholder, is_training) init_op = tf.global_variables_initializer() saver = tf.train.Saver(max_to_keep=50) session_config = tf.ConfigProto() sess = tf.Session(graph=graph, config=session_config) sess.run(init_op) saver.restore(sess, restore_path) main_output_dir = os.path.join( output_root_dir, "{}x{}".format(config.IMAGE_SIZE[0], config.IMAGE_SIZE[1])) if not os.path.exists(main_output_dir): os.makedirs(main_output_dir) # npy files for DLK debug. if image_path: all_ops = _minimal_operations(sess) npy_output_dir = os.path.join(main_output_dir, "inference_test_data") if not os.path.exists(npy_output_dir): os.makedirs(npy_output_dir) raw_image = load_image(*config.IMAGE_SIZE) image = _pre_process(raw_image, config.PRE_PROCESSOR, config.DATA_FORMAT) images = np.expand_dims(image, axis=0) feed_dict = { images_placeholder: images, } all_outputs = [] index = 0 for op in all_ops: for op_output in op.outputs: val = sess.run(op_output.name, feed_dict=feed_dict) name = '%03d' % index + '_' + op_output.name.replace('/', '_') all_outputs.append({'val': val, 'name': name}) index += 1 _save_npy(image_path, npy_output_dir, image, raw_image, all_outputs, config.IMAGE_SIZE) yaml_names = config_util.save_yaml(main_output_dir, config) pb_name = executor.save_pb_file(sess, main_output_dir) message = """ Create pb and yaml files in: {} pb: {} yaml: {}, {} """.format(main_output_dir, pb_name, *yaml_names) if image_path: message += "Create npy files in under `inference_test_data` folder \n" message += "npy: {}".format([d["name"] for d in all_outputs] + [ "raw_image", "preprocessed_image", ]) print(message) print("finish") return main_output_dir
self.sess = tf.Session(graph=graph, config=session_config) self.sess.run(init_op) saver.restore(self.sess, restore_path) def __call__(self, input_data): feed_dict = {self.images_placeholder: input_data * (1 / 255.0)} t_begin = time.time() output = self.sess.run(self.output_op, feed_dict=feed_dict) calc_time = time.time() - t_begin return output, calc_time if __name__ == '__main__': environment.init(args.experiment_id) config = config_util.load_from_experiment() print(config) if args.config_file is not None: config = config_util.merge(config, config_util.load(args.config_file)) if args.restore_path is None: restore_file = search_restore_filename(environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) else: restore_path = args.restore_path print("Restore from {}".format(restore_path)) inference_model = Inference(config, restore_path) window_name = os.path.basename(restore_path) run_demo(inference_model, diff_step=args.diff_step, window_name=window_name)
def _run(config_file, experiment_id, restore_path, image_size, step_size, cpu): if experiment_id: environment.init(experiment_id) config = config_util.load_from_experiment() if config_file: config = config_util.merge(config, config_util.load(config_file)) if restore_path is None: restore_file = executor.search_restore_filename( environment.CHECKPOINTS_DIR) restore_path = os.path.join(environment.CHECKPOINTS_DIR, restore_file) if not os.path.exists("{}.index".format(restore_path)): raise Exception( "restore file {} dont exists.".format(restore_path)) else: experiment_id = "measure_latency" environment.init(experiment_id) config = config_util.load(config_file) config.BATCH_SIZE = 1 config.NETWORK.BATCH_SIZE = 1 config.DATASET.BATCH_SIZE = 1 if list(image_size) != [None, None]: config.IMAGE_SIZE = list(image_size) config.NETWORK.IMAGE_SIZE = list(image_size) # override pre processes image size. if config.PRE_PROCESSOR: config.PRE_PROCESSOR.set_image_size(image_size) # override post processes image size. if config.POST_PROCESSOR: config.POST_PROCESSOR.set_image_size(image_size) print("Override IMAGE_SIZE", config.IMAGE_SIZE) executor.init_logging(config) config_util.display(config) overall_times, only_network_times = _measure_time(config, restore_path, step_size) overall_times = np.array(overall_times) only_network_times = np.array(only_network_times) # list of physical_device_desc devices = [ device.physical_device_desc for device in device_lib.list_local_devices() if device.physical_device_desc ] message = """ ---- measure latency result ---- total number of execution (number of samples): {} network: {} use gpu by network: {} image size: {} devices: {} * overall (include pre-post-process which execute on cpu) total time: {:.4f} msec latency mean (SD=standard deviation): {:.4f} (SD={:.4f}) msec, min: {:.4f} msec, max: {:.4f} msec FPS mean (SD=standard deviation): {:.4f} (SD={:.4f}), min: {:.4f}, max: {:.4f} * network only (exclude pre-post-process): total time: {:.4f} msec latency mean (SD=standard deviation): {:.4f} (SD={:.4f}) msec, min: {:.4f} msec, max: {:.4f} msec FPS mean (SD=standard deviation): {:.4f} (SD={:.4f}), min: {:.4f}, max: {:.4f} ---- measure latency result ---- """.format( step_size, config.NETWORK_CLASS.__name__, not cpu, config.IMAGE_SIZE, devices, # overall np.sum(overall_times) * 1000, # latency np.mean(overall_times) * 1000, np.std(overall_times) * 1000, np.min(overall_times) * 1000, np.max(overall_times) * 1000, # FPS np.mean(1 / overall_times), np.std(1 / overall_times), np.min(1 / overall_times), np.max(1 / overall_times), # network only np.sum(only_network_times) * 1000, # latency np.mean(only_network_times) * 1000, np.std(only_network_times) * 1000, np.min(only_network_times) * 1000, np.max(only_network_times) * 1000, # FPS np.mean(1 / only_network_times), np.std(1 / only_network_times), np.min(1 / only_network_times), np.max(1 / only_network_times), ) print(message)