def preprocess_voc(): """Resizes all VOC images to 300x300 and saves them into .ppm files. This script assumes all images fetched to network in batches have size 300x300, so in this function we preproceess all VOC images to fit that format. """ voc_root = PATHS.get_voc_dir_path() voc_jpegs = glob.glob(os.path.join(voc_root, 'JPEGImages', '*.jpg')) voc_ppms = glob.glob(os.path.join(voc_root, 'PPMImages', '*.ppm')) # Check if preprocessing is needed by comparing # image names between JPEGImages and PPMImages voc_jpegs_basenames = \ [os.path.splitext(os.path.basename(p))[0] for p in voc_jpegs] voc_ppms_basenames = \ [os.path.splitext(os.path.basename(p))[0] for p in voc_ppms] # If lists are not the same, preprocessing is needed if sorted(voc_jpegs_basenames) != sorted(voc_ppms_basenames): print("Preprocessing VOC dataset. It may take few minutes.") # Make PPMImages directory if it doesn't exist voc_ppms_path = PATHS.get_voc_ppm_img_path() if not os.path.exists(os.path.dirname(voc_ppms_path)): os.makedirs(os.path.dirname(voc_ppms_path)) # For each .jpg file, make a resized # .ppm copy to fit model input expectations for voc_jpeg_path in voc_jpegs: voc_jpeg_basename = os.path.basename(voc_jpeg_path) voc_ppm_path = voc_ppms_path.format( os.path.splitext(voc_jpeg_basename)[0]) if not os.path.exists(voc_ppm_path): img_pil = Image.open(voc_jpeg_path) img_pil = img_pil.resize(size=(ModelData.get_input_width(), ModelData.get_input_height()), resample=Image.BILINEAR) img_pil.save(voc_ppm_path)
def extract_voc_data_if_needed(): if os.path.exists(PATHS.get_voc_dir_path()): return voc_archive_path = PATHS.get_data_file_path('VOCtest_06-Nov-2007.tar') print("Unpacking {}".format(voc_archive_path)) with tarfile.open(voc_archive_path, "r") as tar: tar.extractall(path=PATHS.get_sample_root()) print("Unpacking done!")
def parse_commandline_arguments(): """Parses command line arguments and adjusts internal data structures.""" # Define script command line arguments parser = argparse.ArgumentParser(description='Run object detection evaluation on VOC2007 dataset.') parser.add_argument('inference_backend', metavar='INFERENCE_BACKEND', type=str, choices=['tensorrt', 'tensorflow'], default='tensorrt', nargs='?', help='inference backend to run evaluation with') parser.add_argument('-p', '--precision', type=int, choices=[32, 16], default=32, help='desired TensorRT float precision to build an engine with') parser.add_argument('-b', '--max_batch_size', type=int, default=64, help='max TensorRT engine batch size') parser.add_argument('-f', '--force_inference', action='store_true', help='force model inference even if detections exist') parser.add_argument('-w', '--workspace_dir', help='sample workspace directory') parser.add_argument('-fc', '--flatten_concat', help='path of built FlattenConcat plugin') parser.add_argument('-voc', '--voc_dir', help='VOC2007 root directory') # Parse arguments passed args = parser.parse_args() # Adjust global Paths data structure adjust_paths(args) # Verify Paths after adjustments. This also exits script if verification fails PATHS.verify_all_paths(should_verify_voc=True) # Fetch directory to save inference results to, create it if it doesn't exist trt_engine_datatype = None trt_engine_path = None if args.inference_backend == 'tensorrt': # In case of TensorRT we also fetch engine data type and engine path trt_engine_datatype = TRT_PRECISION_TO_DATATYPE[args.precision] trt_engine_path = PATHS.get_engine_path(trt_engine_datatype, args.max_batch_size) if not os.path.exists(os.path.dirname(trt_engine_path)): os.makedirs(os.path.dirname(trt_engine_path)) results_dir = PATHS.get_voc_model_detections_path('tensorrt', trt_engine_datatype) elif args.inference_backend == 'tensorflow': results_dir = PATHS.get_voc_model_detections_path('tensorflow') if not os.path.exists(results_dir): os.makedirs(results_dir) # Return parsed arguments for further functions to use parsed = { 'inference_backend': args.inference_backend, 'max_batch_size': args.max_batch_size, 'force_inference': args.force_inference, 'results_dir': results_dir, 'trt_engine_path': trt_engine_path, 'trt_engine_datatype': trt_engine_datatype } return parsed
def main(): # Parse arguments args = parse_commandline_arguments() # Loading FlattenConcat plugin library using CDLL has a side # effect of loading FlattenConcat plugin into internal TensorRT # PluginRegistry data structure. This will be needed when parsing # network into UFF, since some operations will need to use this plugin try: ctypes.CDLL(PATHS.get_flatten_concat_plugin_path()) except: print("Error: {}\n{}\n{}".format( "Could not find {}".format(PATHS.get_flatten_concat_plugin_path()), "Make sure you have compiled FlattenConcat custom plugin layer", "For more details, check README.md")) sys.exit(1) # build engine trt_inference_wrapper = inference_utils.TRTInference( args.engine_path, args.model_file, trt.DataType.HALF, 1) inference_time = [] cnt = 0 cap = cv2.VideoCapture(args.video_file) start = datetime.now() success, frame = cap.read() while success: cnt += 1 frame = preprocess_frame(frame) start_infer = datetime.now() trt_inference_wrapper.infer_numpy(frame) end_infer = datetime.now() inference_time.append( (end_infer - start_infer).total_seconds() * 1000.0) success, frame = cap.read() end = datetime.now() time_delta = (end - start).total_seconds() fps = cnt / time_delta print( "===============================================================================" ) print("Process time (exclude load model time): {time:.2f}s".format( time=time_delta)) print("Total #frames: {cnt}".format(cnt=cnt)) print("Process FPS (exclude load model time): {time:.2f}".format(time=fps)) print("Average inference time is: {time:.2f}ms".format( time=np.mean(inference_time))) print( "===============================================================================" )
def main(): # Parse command line arguments args = parse_commandline_arguments() # Loading FlattenConcat plugin library using CDLL has a side # effect of loading FlattenConcat plugin into internal TensorRT # PluginRegistry data structure. This will be needed when parsing # network into UFF, since some operations will need to use this plugin try: ctypes.CDLL(PATHS.get_flatten_concat_plugin_path()) except: print( "Error: {}\n{}\n{}".format( "Could not find {}".format(PATHS.get_flatten_concat_plugin_path()), "Make sure you have compiled FlattenConcat custom plugin layer", "For more details, check README.md" ) ) sys.exit(1) # Fetch .uff model path, convert from .pb # if needed, using prepare_ssd_model ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) if not os.path.exists(ssd_model_uff_path): model_utils.prepare_ssd_model(MODEL_NAME) # Set up all TensorRT data structures needed for inference trt_inference_wrapper = inference_utils.TRTInference( args.trt_engine_path, ssd_model_uff_path, trt_engine_datatype=args.trt_engine_datatype, batch_size=args.max_batch_size) # Start measuring time inference_start_time = time.time() # Get TensorRT SSD model output detection_out, keep_count_out = \ trt_inference_wrapper.infer(args.input_img_path) # Make PIL.Image for drawing bounding boxes and # let analyze_prediction() draw them based on model output img_pil = Image.open(args.input_img_path) prediction_fields = len(TRT_PREDICTION_LAYOUT) for det in range(int(keep_count_out[0])): analyze_prediction(detection_out, det * prediction_fields, img_pil) # Output total [img load + inference + drawing bboxes] time print("Total time taken for one image: {} ms\n".format( int(round((time.time() - inference_start_time) * 1000)))) # Save output image and output path img_pil.save(args.output) print("Saved output image to: {}".format(args.output))
def parse_commandline_arguments(): """Parses command line arguments and adjusts internal data structures.""" # Define script command line arguments parser = argparse.ArgumentParser( description='Run object detection inference on input image.') parser.add_argument('input_img_path', metavar='INPUT_IMG_PATH', help='an image file to run inference on') parser.add_argument( '-p', '--precision', type=int, choices=[32, 16], default=32, help='desired TensorRT float precision to build an engine with') parser.add_argument('-b', '--max_batch_size', type=int, default=1, help='max TensorRT engine batch size') parser.add_argument('-w', '--workspace_dir', help='sample workspace directory') parser.add_argument('-fc', '--flatten_concat', help='path of built FlattenConcat plugin') # Parse arguments passed args = parser.parse_args() # Set FlattenConcat TRT plugin path and # workspace dir path if passed by user if args.flatten_concat: PATHS.set_flatten_concat_plugin_path(args.flatten_concat) if args.workspace_dir: PATHS.set_workspace_dir_path(args.workspace_dir) if not os.path.exists(PATHS.get_workspace_dir_path()): os.makedirs(PATHS.get_workspace_dir_path()) # Verify Paths after adjustments. This also exits script if verification fails PATHS.verify_all_paths() # Fetch TensorRT engine path and datatype trt_engine_datatype = TRT_PRECISION_TO_DATATYPE[args.precision] trt_engine_path = PATHS.get_engine_path(trt_engine_datatype, args.max_batch_size) if not os.path.exists(os.path.dirname(trt_engine_path)): os.makedirs(os.path.dirname(trt_engine_path)) parsed = { 'input_img_path': args.input_img_path, 'max_batch_size': args.max_batch_size, 'trt_engine_datatype': trt_engine_datatype, 'trt_engine_path': trt_engine_path } return parsed
def do_python_eval(results_dir): cachedir = PATHS.get_voc_annotation_cache_path() aps = [] for i, cls in enumerate(voc_utils.VOC_CLASSES_LIST): filename = get_voc_results_file_template(cls, results_dir) rec, prec, ap = voc_eval( filename, PATHS.get_voc_image_set_path(), cls, cachedir, ovthresh=0.5) aps += [ap] print('AP for {} = {:.4f}'.format(cls, ap)) print('Mean AP = {:.4f}'.format(np.mean(aps)))
def _extract_model(silent=False): """Extract model from Tensorflow model zoo. Args: silent (bool): if False, writes progress messages to stdout """ maybe_print(not silent, "Preparing pretrained model") model_dir = PATHS.get_models_dir_path() maybe_mkdir(model_dir) model_archive_path = PATHS.get_data_file_path( 'ssd_inception_v2_coco_2017_11_17.tar.gz') maybe_print(not silent, "Unpacking {}".format(model_archive_path)) with tarfile.open(model_archive_path, "r:gz") as tar: tar.extractall(path=model_dir) maybe_print(not silent, "Model ready")
def main(): # Parse command line arguments args = parse_commandline_arguments() # Fetch .uff model path ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) # Set up all TensorRT data structures needed for inference trt_inference_wrapper = TRTInference( args.trt_engine_path, ssd_model_uff_path, trt_engine_datatype=args.trt_engine_datatype, batch_size=args.max_batch_size) # Start measuring time inference_start_time = time.time() # Get TensorRT SSD model output detection_out, keep_count_out = \ trt_inference_wrapper.infer(args.input_img_path) # Make PIL.Image for drawing bounding boxes and # let analyze_prediction() draw them based on model output img_pil = Image.open(args.input_img_path) prediction_fields = len(TRT_PREDICTION_LAYOUT) for det in range(int(keep_count_out[0])): analyze_prediction(detection_out, det * prediction_fields, img_pil) # Output total [img load + inference + drawing bboxes] time print("Total time taken for one image: {} ms\n".format( int(round((time.time() - inference_start_time) * 1000)))) # Save output image and output path img_pil.save(args.output) print("Saved output image to: {}".format(args.output))
def main(): # Parse command line arguments args = parse_commandline_arguments() # Fetch .uff model path ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) # convert from .pb if needed, using prepare_ssd_model if not os.path.exists(ssd_model_uff_path): model_utils.prepare_ssd_model(MODEL_NAME)
def __init__(self, proto, model, labelmap_file, gpu_mode, trt_mode, batch_size, resolution, precision): self.batch_size = batch_size TRT_PRECISION_TO_DATATYPE = { 16: trt.DataType.HALF, 32: trt.DataType.FLOAT } trt_engine_datatype = TRT_PRECISION_TO_DATATYPE[precision] tyolo_model_path = model tyolo_deploy_path = proto trt_engine_path = PATHS.get_engine_path(trt_engine_datatype, batch_size) print("trt_engine_path:", trt_engine_path) try: os.makedirs(os.path.dirname(trt_engine_path)) except: pass # override native resolution with command line or prototxt try: import re if resolution != "": wh = resolution.split('x') w = int(wh[0]) h = int(wh[1]) f = open(tyolo_deploy_path, 'r') contents = f.read() f.close() contents = re.sub('(?<=input: "data"\ninput_shape {\n dim: 1\n dim: 3\n dim: )[0-9]+', str(h), contents) contents = re.sub('(?<=input: "data"\ninput_shape {\n dim: 1\n dim: 3\n dim: ' + str(h) + '\n dim: )[0-9]+', str(w), contents) f = open(tyolo_deploy_path, 'w') f.write(contents) f.close() else: f = open(tyolo_deploy_path, 'r') contents = f.read() f.close() dim = re.search('(?<=input: "data"\ninput_shape {\n dim: 1\n dim: 3\n dim: )[0-9]+', contents) h = contents[dim.span()[0]:dim.span()[1]] dim = re.search('(?<=input: "data"\ninput_shape {\n dim: 1\n dim: 3\n dim: ' + h + '\n dim: )[0-9]+', contents) w = int(contents[dim.span()[0]:dim.span()[1]]) h = int(h) import utils.model as model_utils model_utils.ModelData.INPUT_SHAPE = (3, h, w) except Exception as e: import logging logging.info('Bad resolution, using defaults') # Set up all TensorRT data structures needed for inference self.trt_inference_wrapper = inference_utils.TRTInference( tyolo_deploy_path, trt_engine_path, tyolo_model_path, trt_engine_datatype=trt_engine_datatype, batch_size=batch_size)
def prepare_ssd_model(model_name="ssd_inception_v2_coco_2017_11_17", silent=False): """Downloads pretrained object detection model and converts it to UFF. The model is downloaded from Tensorflow object detection model zoo. Currently only ssd_inception_v2_coco_2017_11_17 model is supported due to model_to_uff() using logic specific to that network when converting. Args: model_name (str): chosen object detection model silent (bool): if True, writes progress messages to stdout """ if model_name != "ssd_inception_v2_coco_2017_11_17": raise NotImplementedError( "Model {} is not supported yet".format(model_name)) download_model(model_name, silent) ssd_pb_path = PATHS.get_model_pb_path(model_name) ssd_uff_path = PATHS.get_model_uff_path(model_name) model_to_uff(ssd_pb_path, ssd_uff_path, silent)
def download_model(model_name, silent=False): """Downloads model_name from Tensorflow model zoo. Args: model_name (str): chosen object detection model silent (bool): if True, writes progress messages to stdout """ maybe_print(not silent, "Preparing pretrained model") model_dir = PATHS.get_models_dir_path() maybe_mkdir(model_dir) model_url = PATHS.get_model_url(model_name) model_archive_path = os.path.join(model_dir, "{}.tar.gz".format(model_name)) download_file(model_url, model_archive_path, silent) maybe_print(not silent, "Download complete\nUnpacking {}".format(model_archive_path)) with tarfile.open(model_archive_path, "r:gz") as tar: tar.extractall(path=model_dir) maybe_print(not silent, "Extracting complete\nRemoving {}".format(model_archive_path)) os.remove(model_archive_path) maybe_print(not silent, "Model ready")
def parse_commandline_arguments(): """Parses command line arguments and adjusts internal data structures.""" # Define script command line arguments parser = argparse.ArgumentParser( description='Run object detection inference on input image.') parser.add_argument('input_img_path', metavar='INPUT_IMG_PATH', help='an image file to run inference on') parser.add_argument( '-p', '--precision', type=int, choices=[32, 16], default=32, help='desired TensorRT float precision to build an engine with') parser.add_argument('-b', '--max_batch_size', type=int, default=1, help='max TensorRT engine batch size') parser.add_argument('-w', '--workspace_dir', help='sample workspace directory') parser.add_argument("-o", "--output", help="path of the output file", default=os.path.join(PATHS.get_sample_root(), "image_inferred.jpg")) # Parse arguments passed args = parser.parse_args() # Set workspace dir path if passed by user if args.workspace_dir: PATHS.set_workspace_dir_path(args.workspace_dir) try: os.makedirs(PATHS.get_workspace_dir_path()) except: pass # Verify Paths after adjustments. This also exits script if verification fails PATHS.verify_all_paths() # Fetch TensorRT engine path and datatype args.trt_engine_datatype = TRT_PRECISION_TO_DATATYPE[args.precision] args.trt_engine_path = PATHS.get_engine_path(args.trt_engine_datatype, args.max_batch_size) try: os.makedirs(os.path.dirname(args.trt_engine_path)) except: pass return args
def main(): # Parse command line arguments args = parse_commandline_arguments() # Fetch .uff model path, convert from .pb # if needed, using prepare_ssd_model ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) if not os.path.exists(ssd_model_uff_path): model_utils.prepare_ssd_model(MODEL_NAME) # Set up all TensorRT data structures needed for inference trt_inference_wrapper = inference_utils.TRTInference( args.trt_engine_path, ssd_model_uff_path, trt_engine_datatype=args.trt_engine_datatype, calib_dataset=args.calib_dataset, batch_size=args.max_batch_size) print("TRT ENGINE PATH", args.trt_engine_path) if args.camera == True: print('Running webcam:', args.camera) # Define the video stream cap = cv2.VideoCapture( 0) # Change only if you have more than one webcams # Loop for running inference on frames from the webcam while True: # Read frame from camera (and expand its dimensions to fit) ret, image_np = cap.read() # Actually run inference detection_out, keep_count_out = trt_inference_wrapper.infer_webcam( image_np) # Overlay the bounding boxes on the image # let analyze_prediction() draw them based on model output img_pil = Image.fromarray(image_np) prediction_fields = len(TRT_PREDICTION_LAYOUT) for det in range(int(keep_count_out[0])): analyze_prediction(detection_out, det * prediction_fields, img_pil) final_img = np.asarray(img_pil) # Display output cv2.imshow('object detection', final_img) if cv2.waitKey(25) & 0xFF == ord('q'): cv2.destroyAllWindows() break
def main(): # Parse command line arguments #解析命令行参数,具体参考本文件下的实现 args = parse_commandline_arguments() # Fetch .uff model path, convert from .pb # if needed, using prepare_ssd_model #获取相应的uff模型的路径 #get_model_uff_path参考utils/paths.py下的实现 ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) #如果不存在uff模型 if not os.path.exists(ssd_model_uff_path): #从pb模型完成到uff模型的转换 #prepare_ssd_model参考utils/model.py下的实现 model_utils.prepare_ssd_model(MODEL_NAME) # Set up all TensorRT data structures needed for inference #建立推理所需要的数据结构 #具体参考utils/inference.py下的实现 trt_inference_wrapper = inference_utils.TRTInference( args.trt_engine_path, ssd_model_uff_path, trt_engine_datatype=args.trt_engine_datatype, batch_size=args.max_batch_size) # Start measuring time inference_start_time = time.time() # Get TensorRT SSD model output #获取相应的推理输出 #参考utils/inference.py detection_out, keep_count_out = \ trt_inference_wrapper.infer(args.input_img_path) # Make PIL.Image for drawing bounding boxes and # let analyze_prediction() draw them based on model output img_pil = Image.open(args.input_img_path) prediction_fields = len(TRT_PREDICTION_LAYOUT) for det in range(int(keep_count_out[0])): #analyze_prediction参考本文件的实现 analyze_prediction(detection_out, det * prediction_fields, img_pil) # Output total [img load + inference + drawing bboxes] time print("Total time taken for one image: {} ms\n".format( int(round((time.time() - inference_start_time) * 1000)))) # Save output image and output path #保存相应的结果 img_pil.save(args.output) print("Saved output image to: {}".format(args.output))
def main(): # Parse command line arguments args = parse_commandline_arguments() # Loading FlattenConcat plugin library using CDLL has a side # effect of loading FlattenConcat plugin into internal TensorRT # PluginRegistry data structure. This will be needed when parsing # network into UFF, since some operations will need to use this plugin try: ctypes.CDLL(PATHS.get_flatten_concat_plugin_path()) except: print( "Error: {}\n{}\n{}".format( "Could not find {}".format(PATHS.get_flatten_concat_plugin_path()), "Make sure you have compiled FlattenConcat custom plugin layer", "For more details, check README.md" ) ) sys.exit(1) input_shape = (3, 300, 300) if not args.input_shape else args.input_shape print("[SSD Mobilenet V2 Converter] Converting {input_file} to UFF format...".format(input_file=args.input_file)) if args.model_name == "ssd_mobilenet_v2_coco": model_utils.model_to_uff(args.input_file, args.output_path, preprocess_func=model_utils.ssd_mobilenet_v2_unsupported_nodes_to_plugin_nodes, input_shape=input_shape) elif args.model_name == "ssd_mobilenet_v1_coco": model_utils.model_to_uff(args.input_file, args.output_path, preprocess_func=model_utils.ssd_mobilenet_v1_unsupported_nodes_to_plugin_nodes, input_shape=input_shape) else: raise ValueError("Got unsupported model: {model_name}".format(model_name=args.model_name)) print("[SSD Mobilenet V2 Converter] Convert succeed, output is saved to {output_path}" .format(output_path=args.output_path))
def adjust_paths(args): """Adjust all file/directory paths, arguments passed by user. During script launch, user can pass several arguments to the script (e.g. --workspace_dir, --voc_dir), that define where script will look for the files needed for execution. This function adjusts internal Paths Python datastructure to accomodate for changes from defaults requested by user through appropriate command line arguments. Args: args (argparse.Namespace): parsed user arguments """ if args.voc_dir: PATHS.set_voc_dir_path(args.voc_dir) if args.flatten_concat: PATHS.set_flatten_concat_plugin_path(args.flatten_concat) if args.workspace_dir: PATHS.set_workspace_dir_path(args.workspace_dir) if not os.path.exists(PATHS.get_workspace_dir_path()): os.makedirs(PATHS.get_workspace_dir_path())
def read_voc_annotations(annotations_dir, image_numbers): if not os.path.isdir(annotations_dir): os.makedirs(annotations_dir) annotations_file = os.path.join(annotations_dir, 'annots.pkl') if not os.path.isfile(annotations_file): # If annotations were not present, compute them detections = {} for i, image_num in enumerate(image_numbers): detections[image_num] = parse_voc_annotation_xml( PATHS.get_voc_annotation_path().format(image_num)) if i % 100 == 0: print('Reading annotation for {:d}/{:d}'.format( i + 1, len(image_numbers))) # Save print('Saving cached annotations to {:s}'.format(annotations_file)) with open(annotations_file, 'wb') as f: pickle.dump(detections, f) else: # If annotations were present, load them with open(annotations_file, 'rb') as f: detections = pickle.load(f) return detections
def parse_commandline_arguments(): """Parses command line arguments and adjusts internal data structures.""" # Define script command line arguments parser = argparse.ArgumentParser( description='Run object detection inference on input image.') parser.add_argument('-w', '--workspace_dir', help='sample workspace directory') parser.add_argument( '-d', '--data', help= "Specify the data directory where it is saved in. $TRT_DATA_DIR will be overwritten by this argument." ) args, _ = parser.parse_known_args() data_dir = os.environ.get('TRT_DATA_DIR', None) if args.data is None else args.data if data_dir is None: raise ValueError( "Data directory must be specified by either `-d $DATA` or environment variable $TRT_DATA_DIR." ) PATHS.set_data_dir_path(data_dir) # Set workspace dir path if passed by user if args.workspace_dir: PATHS.set_workspace_dir_path(args.workspace_dir) try: os.makedirs(PATHS.get_workspace_dir_path()) except: pass # Verify Paths after adjustments. This also exits script if verification fails PATHS.verify_all_paths() return args
skip_inference = should_skip_inference(parsed) # And if inference will not be skipped, then we # create files to store its results in detection_files = {} if not skip_inference: for voc_class in VOC_CLASSES: detection_files[voc_class] = open( os.path.join(parsed['results_dir'], 'det_test_{}.txt'.format(voc_class)), 'w') # Loading FlattenConcat plugin library using CDLL has a side # effect of loading FlattenConcat plugin into internal TensorRT # PluginRegistry data structure. This will be needed when parsing # network into UFF, since some operations will need to use this plugin try: ctypes.CDLL(PATHS.get_flatten_concat_plugin_path()) except FileNotFoundError: print("Error: {}\n{}\n{}".format( "Could not find {}".format(PATHS.get_flatten_concat_plugin_path()), "Make sure you have compiled FlattenConcat custom plugin layer", "For more details, check README.md")) sys.exit(1) # Fetch frozen model .pb path... ssd_model_pb_path = PATHS.get_model_pb_path(MODEL_NAME) # ...and .uff path, if needed (converting .pb to .uff if not already done) if parsed['inference_backend'] == 'tensorrt': ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) if not os.path.exists(ssd_model_uff_path): model_utils.prepare_ssd_model(MODEL_NAME)
import numpy as np import scipy.io as scio import sys import os import argparse import pickle from sklearn import metrics import json from utils.util import score_smoothing from utils.paths import PATHS sys.path.append('../') DATA_DIR = PATHS.get_dataset_dir_path() # normalize scores in each sub video NORMALIZE = True # number of history frames, since in prediction based method, # the first 4 frames can not be predicted, so that # the first 4frames are undecidable, we just ignore the first 4 frames DECIDABLE_IDX = 2 def parser_args(): parser = argparse.ArgumentParser( description='evaluating the model, computing the roc/auc.') parser.add_argument('-f', '--file', type=str,
def parse_commandline_arguments(): """Parses command line arguments and adjusts internal data structures.""" # Define script command line arguments parser = argparse.ArgumentParser( description='Run object detection inference on input image.') parser.add_argument('--input_img_path', metavar='INPUT_IMG_PATH', help='an image file to run inference on') parser.add_argument( '-p', '--precision', type=int, choices=[32, 16, 8], default=32, help='desired TensorRT float precision to build an engine with') parser.add_argument('-b', '--max_batch_size', type=int, default=1, help='max TensorRT engine batch size') parser.add_argument('-w', '--workspace_dir', help='sample workspace directory') parser.add_argument('-fc', '--flatten_concat', help='path of built FlattenConcat plugin') parser.add_argument('-d', '--calib_dataset', default='../VOCdevkit/VOC2007/JPEGImages', help='path to the calibration dataset') parser.add_argument('-c', '--camera', default=True, help='if True, will run webcam application') # Parse arguments passed args = parser.parse_args() # Set FlattenConcat TRT plugin path and # workspace dir path if passed by user if args.flatten_concat: PATHS.set_flatten_concat_plugin_path(args.flatten_concat) if args.workspace_dir: PATHS.set_workspace_dir_path(args.workspace_dir) try: os.makedirs(PATHS.get_workspace_dir_path()) except: pass # Verify Paths after adjustments. This also exits script if verification fails PATHS.verify_all_paths() # Fetch TensorRT engine path and datatype args.trt_engine_datatype = TRT_PRECISION_TO_DATATYPE[args.precision] args.trt_engine_path = PATHS.get_engine_path(args.trt_engine_datatype, args.max_batch_size) try: os.makedirs(os.path.dirname(args.trt_engine_path)) except: pass return args
from sklearn.externals import joblib import sys from scripts import inference from models.CAE import CAE_encoder from utils import util import os import argparse import numpy as np import pickle import time from utils import evaluate from utils.paths import PATHS sys.path.append("../") prefix = PATHS.get_dataset_dir_path() def arg_parse(): parser = argparse.ArgumentParser() parser.add_argument("-g", "--gpu", type=str, default="0", help="Use which gpu?") parser.add_argument("-d", "--dataset", type=str, help="Train on which dataset") parser.add_argument("-b", "--bn",
def main(): # Parse command line arguments parsed = parse_commandline_arguments() # Check if inference should be skipped (if model inference # results are already computed, we don't need to recompute # them for VOC mAP computation) skip_inference = should_skip_inference(parsed) # And if inference will not be skipped, then we # create files to store its results in detection_files = {} if not skip_inference: for voc_class in VOC_CLASSES: detection_files[voc_class] = open( os.path.join(parsed['results_dir'], 'det_test_{}.txt'.format(voc_class)), 'w') # Fetch frozen model .pb path... ssd_model_pb_path = PATHS.get_model_pb_path(MODEL_NAME) # ...and .uff path, if needed (converting .pb to .uff if not already done) if parsed['inference_backend'] == 'tensorrt': ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) # This block of code sets up and performs inference, if needed if not skip_inference: # Preprocess VOC dataset if necessary by resizing images preprocess_voc() # Fetch image list and input .ppm files path with open(PATHS.get_voc_image_set_path(), 'r') as f: voc_image_numbers = f.readlines() voc_image_numbers = [line.strip() for line in voc_image_numbers] voc_image_path = PATHS.get_voc_ppm_img_path() # Tensorflow and TensorRT paths are a little bit different, # so we must treat each one individually if parsed['inference_backend'] == 'tensorrt': # TRTInference initialization initializes # all TensorRT structures, creates engine if it doesn't # already exist and finally saves it to file for future uses from utils.inference_trt import TRTInference trt_inference_wrapper = TRTInference(parsed['trt_engine_path'], ssd_model_uff_path, parsed['trt_engine_datatype'], parsed['max_batch_size']) # Outputs from TensorRT are handled differently than # outputs from Tensorflow, that's why we use another # function to produce the detections from them produce_tensorrt_detections(detection_files, trt_inference_wrapper, parsed['max_batch_size'], voc_image_numbers, voc_image_path) elif parsed['inference_backend'] == 'tensorflow': # In case of Tensorflow all we need to # initialize inference is frozen model... from utils.inference_tf import TensorflowInference tf_inference_wrapper = TensorflowInference(ssd_model_pb_path) # ...and after initializing it, we can # proceed to producing detections produce_tensorflow_detections(detection_files, tf_inference_wrapper, parsed['max_batch_size'], voc_image_numbers, voc_image_path) # Flush detection to files to make sure evaluation is correct for key in detection_files: detection_files[key].flush() # Do mAP computation based on saved detections voc_mAP_utils.do_python_eval(parsed['results_dir']) # Close detection files, they are not needed anymore for key in detection_files: detection_files[key].close()
def parse_commandline_arguments(): """Parses command line arguments and adjusts internal data structures.""" # Define script command line arguments parser = argparse.ArgumentParser( description='Run object detection evaluation on VOC2007 dataset.') parser.add_argument('inference_backend', metavar='INFERENCE_BACKEND', type=str, choices=['tensorrt', 'tensorflow'], default='tensorrt', nargs='?', help='inference backend to run evaluation with') parser.add_argument( '-p', '--precision', type=int, choices=[32, 16], default=32, help='desired TensorRT float precision to build an engine with') parser.add_argument('-b', '--max_batch_size', type=int, default=64, help='max TensorRT engine batch size') parser.add_argument('-f', '--force_inference', action='store_true', help='force model inference even if detections exist') parser.add_argument('-w', '--workspace_dir', help='sample workspace directory') parser.add_argument( '-d', '--data', help= "Specify the data directory where it is saved in. $TRT_DATA_DIR will be overwritten by this argument." ) args, _ = parser.parse_known_args() data_dir = os.environ.get('TRT_DATA_DIR', None) if args.data is None else args.data if data_dir is None: raise ValueError( "Data directory must be specified by either `-d $DATA` or environment variable $TRT_DATA_DIR." ) adjust_paths(args, data_dir) extract_voc_data_if_needed() # Verify Paths after adjustments. This also exits script if verification fails PATHS.verify_all_paths(should_verify_voc=True) # Fetch directory to save inference results to, create it if it doesn't exist trt_engine_datatype = None trt_engine_path = None if args.inference_backend == 'tensorrt': # In case of TensorRT we also fetch engine data type and engine path trt_engine_datatype = TRT_PRECISION_TO_DATATYPE[args.precision] trt_engine_path = PATHS.get_engine_path(trt_engine_datatype, args.max_batch_size) if not os.path.exists(os.path.dirname(trt_engine_path)): os.makedirs(os.path.dirname(trt_engine_path)) results_dir = PATHS.get_voc_model_detections_path( 'tensorrt', trt_engine_datatype) elif args.inference_backend == 'tensorflow': results_dir = PATHS.get_voc_model_detections_path('tensorflow') if not os.path.exists(results_dir): os.makedirs(results_dir) # Return parsed arguments for further functions to use parsed = { 'inference_backend': args.inference_backend, 'max_batch_size': args.max_batch_size, 'force_inference': args.force_inference, 'results_dir': results_dir, 'trt_engine_path': trt_engine_path, 'trt_engine_datatype': trt_engine_datatype } return parsed
# Check if inference should be skipped (if model inference # results are already computed, we don't need to recompute # them for VOC mAP computation) skip_inference = should_skip_inference(parsed) # And if inference will not be skipped, then we # create files to store its results in detection_files = {} if not skip_inference: for voc_class in VOC_CLASSES: detection_files[voc_class] = open( os.path.join(parsed['results_dir'], 'det_test_{}.txt'.format(voc_class)), 'w') # Fetch frozen model .pb path... ssd_model_pb_path = PATHS.get_model_pb_path(MODEL_NAME) # ...and .uff path, if needed (converting .pb to .uff if not already done) if parsed['inference_backend'] == 'tensorrt': ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) if not os.path.exists(ssd_model_uff_path): model_utils.prepare_ssd_model(MODEL_NAME) # This block of code sets up and performs inference, if needed if not skip_inference: # Preprocess VOC dataset if necessary by resizing images preprocess_voc() # Fetch image list and input .ppm files path with open(PATHS.get_voc_image_set_path(), 'r') as f: voc_image_numbers = f.readlines() voc_image_numbers = [line.strip() for line in voc_image_numbers]
import random from utils import util import sklearn.svm as svm from sklearn.cluster import KMeans from sklearn.externals import joblib from models import CAE from sklearn.linear_model import SGDClassifier from sklearn.multiclass import OneVsRestClassifier from cyvlfeat.kmeans import kmeans, kmeans_quantize from utils.paths import PATHS sys.path.append('../') tf.logging.set_verbosity(tf.logging.DEBUG) summary_save_path_pre = PATHS.get_logs_dir_path() svm_save_dir = PATHS.get_model_svm_dir_path() model_save_path_pre = PATHS.get_model_cae_dir_path() prefix = PATHS.get_sample_root() batch_size = 64 learning_rate = [1e-3, 1e-4] lr_decay_epochs = [100] epochs = 200 ''' The Author said that the model may be better when 90-d one-hot embedding, representing the object class in COCO, add to the feature vector, which is can be activated by '--class_add' '''
def main(max_time, min_time, sum_time, num): # Parse command line arguments args = parse_commandline_arguments() outputdir_path = args.outpath inputdir_path = args.inpath # Fetch .uff model path, convert from .pb # if needed, using prepare_ssd_model ssd_model_uff_path = PATHS.get_model_uff_path(MODEL_NAME) if not os.path.exists(ssd_model_uff_path): model_utils.prepare_ssd_model(MODEL_NAME) # Set up all TensorRT data structures needed for inference trt_inference_wrapper = inference_utils.TRTInference( args.trt_engine_path, ssd_model_uff_path, trt_engine_datatype=args.trt_engine_datatype, calib_dataset=args.calib_dataset, batch_size=args.max_batch_size) ARGS = 3 print("TRT ENGINE PATH", args.trt_engine_path) if args.camera == True: #if True: #print('Running webcam:', args.camera) # Define the video stream #cap = cv2.VideoCapture(0) #cap = cv2.VideoCapture('animal.webm') # Change only if you have more than one webcams cap = cv2.VideoCapture( inputdir_path) # Change only if you have more than one webcams if (cap.isOpened() == False): print("Error opening video stream or file") exit() else: print("success!") # Default resolutions of the frame are obtained.The default resolutions are system dependent. # We convert the resolutions from float to integer. frame_width = int(cap.get(3)) frame_height = int(cap.get(4)) fps = cap.get(cv2.CAP_PROP_FPS) # Define the codec and create VideoWriter object.The output is stored in 'outpy.avi' file. out = cv2.VideoWriter(str(outputdir_path + "/output.avi"), cv2.VideoWriter_fourcc(*'XVID'), fps, (frame_width, frame_height)) # Loop for running inference on frames from the webcam while True: # Read frame from camera (and expand its dimensions to fit) ret, image_np = cap.read() if not ret: print("Video played.") break # Actually run inference cur, detection_out, keep_count_out = trt_inference_wrapper.infer_webcam( image_np) max_time = max(max_time, cur) min_time = min(min_time, cur) sum_time += cur num += 1 # Overlay the bounding boxes on the image # let analyze_prediction() draw them based on model output img_pil = Image.fromarray(image_np) prediction_fields = len(TRT_PREDICTION_LAYOUT) for det in range(int(keep_count_out[0])): analyze_prediction(detection_out, det * prediction_fields, img_pil) final_img = np.asarray(img_pil) out.write(final_img) return outputdir_path, max_time, min_time, sum_time, num
def __init__(self, trt_engine_path, uff_model_path, trt_engine_datatype=trt.DataType.FLOAT, batch_size=1): """Initializes TensorRT objects needed for model inference. Args: trt_engine_path (str): path where TensorRT engine should be stored uff_model_path (str): path of .uff model trt_engine_datatype (trt.DataType): requested precision of TensorRT engine used for inference batch_size (int): batch size for which engine should be optimized for """ # We first load all custom plugins shipped with TensorRT, # some of them will be needed during inference trt.init_libnvinfer_plugins(TRT_LOGGER, '') # Initialize runtime needed for loading TensorRT engine from file self.trt_runtime = trt.Runtime(TRT_LOGGER) # TRT engine placeholder self.trt_engine = None # Display requested engine settings to stdout print("TensorRT inference engine settings:") print(" * Inference precision - {}".format(trt_engine_datatype)) print(" * Max batch size - {}\n".format(batch_size)) # If engine is not cached, we need to build it if not os.path.exists(trt_engine_path): # This function uses supplied .uff file # alongside with UffParser to build TensorRT # engine. For more details, check implmentation # Set up for calibration if trt_engine_datatype == trt.DataType.INT8: with open(PATHS.get_voc_image_set_path(), 'r') as f: voc_image_numbers = f.readlines() voc_image_numbers = [ line.strip() for line in voc_image_numbers ] total_imgs = len(voc_image_numbers) voc_names = [] calibration_cache = "ssd_calibration_eval.cache" for n in range(total_imgs): voc_names.append(voc_image_numbers[n] + ".jpg") _, calib_data = common.find_sample_data( description="Runs a ResNet50 network in Int8 mode", subfolder="JPEGImages", find_files=voc_names) calib = VOCEntropyCalibrator(calib_data, total_imgs, cache_file=calibration_cache) self.trt_engine = engine_utils.build_engine( uff_model_path, calib, TRT_LOGGER, trt_engine_datatype=trt_engine_datatype, batch_size=batch_size) # Save the engine to file engine_utils.save_engine(self.trt_engine, trt_engine_path) # If we get here, the file with engine exists, so we can load it if not self.trt_engine: print("Loading cached TensorRT engine from {}".format( trt_engine_path)) self.trt_engine = engine_utils.load_engine(self.trt_runtime, trt_engine_path) # This allocates memory for network inputs/outputs on both CPU and GPU self.inputs, self.outputs, self.bindings, self.stream = \ engine_utils.allocate_buffers(self.trt_engine) # Execution context is needed for inference self.context = self.trt_engine.create_execution_context() # Allocate memory for multiple usage [e.g. multiple batch inference] input_volume = trt.volume(model_utils.ModelData.INPUT_SHAPE) self.numpy_array = np.zeros( (self.trt_engine.max_batch_size, input_volume))