def main(): parser = argparse.ArgumentParser(description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default="", metavar="FILE", help="path to config file", type=str, ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--skip-test", dest="skip_test", help="Do not test the final model", action="store_true", ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.deprecated.init_process_group( backend="nccl", init_method="env://" ) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_dir = cfg.OUTPUT_DIR if output_dir: mkdir(output_dir) logger = setup_logger("maskrcnn_benchmark", output_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(args) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) logger.info("Loaded configuration file {}".format(args.config_file)) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) model = train(cfg, args.local_rank, args.distributed) if not args.skip_test: test(cfg, model, args.distributed)
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default= "/private/home/fmassa/github/detectron.pytorch_v2/configs/e2e_faster_rcnn_R_50_C4_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--ckpt", help= "The path to the checkpoint for test, default is the latest checkpoint.", default=None, ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 distributed = num_gpus > 1 if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") synchronize() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("maskrcnn_benchmark", save_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) model = build_detection_model(cfg) model.to(cfg.MODEL.DEVICE) # Initialize mixed-precision if necessary use_mixed_precision = cfg.DTYPE == 'float16' amp_handle = amp.init(enabled=use_mixed_precision, verbose=cfg.AMP_VERBOSE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) ckpt = cfg.MODEL.WEIGHT if args.ckpt is None else args.ckpt _ = checkpointer.load(ckpt, use_latest=args.ckpt is None) iou_types = ("bbox", ) if cfg.MODEL.MASK_ON: iou_types = iou_types + ("segm", ) if cfg.MODEL.KEYPOINT_ON: iou_types = iou_types + ("keypoints", ) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): output_folder = os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=distributed) for output_folder, dataset_name, data_loader_val in zip( output_folders, dataset_names, data_loaders_val): inference( model, data_loader_val, dataset_name=dataset_name, iou_types=iou_types, box_only=False if cfg.MODEL.RETINANET_ON else cfg.MODEL.RPN_ONLY, bbox_aug=cfg.TEST.BBOX_AUG.ENABLED, device=cfg.MODEL.DEVICE, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, output_folder=output_folder, ) synchronize()
from PIL import Image import numpy as np import sys import glob import json # call with <directory> <mode> # directory. Must only contain image files. directory: str = sys.argv[1] # mode = "cpu" or "cuda" mode: str = sys.argv[2] # update the config options with the config file cfg.merge_from_file("../configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml") # manual override some options cfg.merge_from_list(["MODEL.DEVICE", mode]) coco_demo = COCODemo( cfg, min_image_size=800, confidence_threshold=0.7, ) def get_file_names() -> list: types = ["*.jpg", "*.png"] names = [] for extension in types: names += glob.glob1(directory, extension) return names
def main(): parser = argparse.ArgumentParser(description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default=None, metavar="FILE", help="path to config file", type=str, ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--skip-test", dest="skip_test", help="Do not test the final model", action="store_true", ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group( backend="nccl", init_method="env://" ) synchronize() if args.config_file is None: args.config_file = str(Path(__file__).parent.joinpath("config", "e2e_mask_rcnn_X_101_32x8d_FPN_1x.yaml")) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_dir = cfg.OUTPUT_DIR if output_dir: mkdir(output_dir) logger = setup_logger("maskrcnn_benchmark", output_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(args) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) logger.info("Loaded configuration file {}".format(args.config_file)) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) model = train(cfg, args.local_rank, args.distributed) if not args.skip_test: run_test(cfg, model, args.distributed)
def segment(queue_in, queue_out, queue_save, device, framerate=1, target_class=[1]): print("Starting the teacher segmentation process") # Define the weights to use config_file = "networks/weights/maskrcnn_weights.yaml" # Update the config options with the config file cfg.merge_from_file(config_file) # Manual override some options cfg.merge_from_list(["MODEL.DEVICE", device]) # Create the maskrcnn model coco_demo = COCODemo( cfg, min_image_size=800, confidence_threshold=0.7, ) # Initialise the variables that will be retrieved in the input queue signal_continue = None input_frame = None input_frame, signal_continue = queue_in.get() # Time counter for slowing the loop time_next_iteration = time.time() + framerate while signal_continue: # Compute the field mask field_mask = None if args.onfield is not None: field_mask = utils.field.compute_soccer_field(input_frame) else: field_mask = np.zeros(input_frame[:, :, 0].shape) + 255 # Get the predictions from Mask-RCNN predictions = coco_demo.run_on_opencv_image(input_frame) # Retrieve the masks masks = predictions.get_field("mask").numpy() # Retrieve the labels labels = predictions.get_field("labels") # Create the final mask final = np.zeros(input_frame[:, :, 0].shape) for mask, label in zip(masks, labels): # Only keep it if it is a person (if target_class=1) if not label in target_class: continue # Only keep if the it intersects the field covering_area = np.sum(mask[0, :, :] * field_mask) if covering_area == 0: continue # Since the mask filled all the requirements, we add it to the final result final = np.logical_or(final, mask[0, :, :]) # Transform the image in the correct format final = final.astype("uint8") # Transform the data so they match the training specs target = torch.from_numpy(1 - final).type(torch.uint8).unsqueeze_(0) input_tensor = utils.image.cvToTorch_(input_frame).unsqueeze_(0) # Send the data to the training process queue_out.put((input_tensor, target, True)) # Rectify the data so it can be saved final = final * 255 # Send the data to save to the writing process for the teacher queue_save.put((input_frame, final, field_mask, True)) # Retrieve the next data input_frame, signal_continue = queue_in.get() # Slow down the loop to keep if time.time() > time_next_iteration: time_next_iteration += framerate continue time_to_sleep = time_next_iteration - time.time() time.sleep(time_to_sleep) time_next_iteration += framerate queue_out.put((None, None, False)) queue_save.put((None, None, None, False)) print("Stopping the teacher segmentation process") time.sleep(15)
from maskrcnn_benchmark.config import cfg from predictor import COCODemo config_file = "../configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml" # update the config options with the config file cfg.merge_from_file(config_file) # manual override some options cfg.merge_from_list(["MODEL.DEVICE", "cpu"]) coco_demo = COCODemo( cfg, min_image_size=800, confidence_threshold=0.7, )
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Webcam Demo") parser.add_argument( "--config-file", default="../configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--confidence-threshold", type=float, default=0.7, help="Minimum score for the prediction to be shown", ) parser.add_argument( "--min-image-size", type=int, default=224, help="Smallest size of the image to feed to the model. " "Model was trained with 800, which gives best results", ) parser.add_argument( "--show-mask-heatmaps", dest="show_mask_heatmaps", help="Show a heatmap probability for the top masks-per-dim masks", action="store_true", ) parser.add_argument( "--masks-per-dim", type=int, default=2, help="Number of heatmaps per dimension to show", ) parser.add_argument( "opts", help="Modify model config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() # load config from file and command-line arguments cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() # prepare object that handles inference plus adds predictions on top of image coco_demo = COCODemo( cfg, confidence_threshold=args.confidence_threshold, show_mask_heatmaps=args.show_mask_heatmaps, masks_per_dim=args.masks_per_dim, min_image_size=args.min_image_size, weight_loading='best_model/model_best.pth', ) images = files_with_ext('test', '.jpg') for image in images: start_time = time.time() img = cv2.imread(image) # ret_val, img = cam.read() composite = coco_demo.run_on_opencv_image(img) print("Time: {:.2f} s / img".format(time.time() - start_time)) output_path = os.path.join('test/' + 'output_' + os.path.basename(image)) print(output_path) # cv2.imshow("COCO detections", composite) cv2.imwrite(output_path, composite)
def main(): # apply_prior prior_mask # 0 - - # 1 Y - # 2 - Y # 3 Y Y parser = argparse.ArgumentParser( description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default="", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--ckpt", help= "The path to the checkpoint for test, default is the latest checkpoint.", default=None, ) parser.add_argument('--num_iteration', dest='num_iteration', help='Specify which weight to load', default=-1, type=int) parser.add_argument('--object_thres', dest='object_thres', help='Object threshold', default=0.4, type=float) # used to be 0.4 or 0.05 parser.add_argument('--human_thres', dest='human_thres', help='Human threshold', default=0.6, type=float) parser.add_argument('--prior_flag', dest='prior_flag', help='whether use prior_flag', default=1, type=int) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 distributed = num_gpus > 1 and torch.cuda.is_available() if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") synchronize() print('prior flag: {}'.format(args.prior_flag)) ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) args.config_file = os.path.join(ROOT_DIR, args.config_file) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("DRG.inference", save_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) model = build_detection_model(cfg) device = torch.device( "cuda") if torch.cuda.is_available() else torch.device("cpu") model.to(device) # Initialize mixed-precision if necessary use_mixed_precision = cfg.DTYPE == 'float16' amp_handle = amp.init(enabled=use_mixed_precision, verbose=cfg.AMP_VERBOSE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) if args.num_iteration != -1: args.ckpt = os.path.join(cfg.OUTPUT_DIR, 'model_%07d.pth' % args.num_iteration) ckpt = cfg.MODEL.WEIGHT if args.ckpt is None else args.ckpt logger.info("Testing checkpoint {}".format(ckpt)) _ = checkpointer.load(ckpt, use_latest=args.ckpt is None) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): if args.num_iteration != -1: output_folder = os.path.join(cfg.OUTPUT_DIR, "inference_sp", dataset_name, "model_%07d" % args.num_iteration) else: output_folder = os.path.join(cfg.OUTPUT_DIR, "inference_sp", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder opt = {} opt['word_dim'] = 300 opt['use_thres_dic'] = 1 for output_folder, dataset_name in zip(output_folders, dataset_names): data = DatasetCatalog.get(dataset_name) data_args = data["args"] test_detection = pickle.load(open(data_args['test_detection_file'], "rb"), encoding='latin1') word_embeddings = pickle.load(open(data_args['word_embedding_file'], "rb"), encoding='latin1') opt['thres_dic'] = pickle.load(open(data_args['threshold_dic'], "rb"), encoding='latin1') output_file = os.path.join(output_folder, 'detection.pkl') # hico_folder = os.path.join(output_folder, 'HICO') output_map_folder = os.path.join(output_folder, 'map') logger.info("Output will be saved in {}".format(output_file)) logger.info("Start evaluation on {} dataset.".format(dataset_name)) run_test(model, dataset_name=dataset_name, test_detection=test_detection, word_embeddings=word_embeddings, output_file=output_file, object_thres=args.object_thres, human_thres=args.human_thres, device=device, cfg=cfg, opt=opt) # Generate_HICO_detection(output_file, hico_folder) compute_hico_map(output_map_folder, output_file, 'test')
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default= "/private/home/fmassa/github/detectron.pytorch_v2/configs/e2e_faster_rcnn_R_50_C4_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 distributed = num_gpus > 1 if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("maskrcnn_benchmark", save_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) model = build_detection_model(cfg) model.to(cfg.MODEL.DEVICE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) _ = checkpointer.load(cfg.MODEL.WEIGHT) iou_types = ("bbox", ) if cfg.MODEL.MASK_ON: iou_types = iou_types + ("segm", ) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): output_folder = os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder if cfg.TEST.MULTI_SCALE: data_loaders_val = [] for min_size_test, max_size_test in cfg.TEST.MULTI_SIZES: cfg.defrost() cfg.INPUT.MIN_SIZE_TEST = min_size_test cfg.INPUT.MAX_SIZE_TEST = max_size_test cfg.freeze() data_loaders_val.extend( make_data_loader(cfg, is_train=False, is_distributed=distributed)) output_folders = output_folders * len(cfg.TEST.MULTI_SIZES) dataset_names = dataset_names * len(cfg.TEST.MULTI_SIZES) else: data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=distributed) predictions = [] for output_folder, dataset_name, data_loader_val in zip( output_folders, dataset_names, data_loaders_val): prediction = inference( model, data_loader_val, dataset_name=dataset_name, iou_types=iou_types, box_only=cfg.MODEL.RPN_ONLY, device=cfg.MODEL.DEVICE, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, output_folder=output_folder, ) synchronize() predictions.append(prediction) if cfg.TEST.MULTI_SCALE: logger.info("Processing multi-scale bbox voting....") voted_predictions = voting( predictions, args.local_rank) # box_voting(predictions, args.local_rank) torch.save(voted_predictions, os.path.join(output_folders[0], 'predictions.pth')) extra_args = dict( box_only=cfg.MODEL.RPN_ONLY, iou_types=iou_types, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, ) evaluate(dataset=data_loaders_val[0].dataset, predictions=voted_predictions, output_folder=output_folders[0], **extra_args) else: for prediction, output_folder, dataset_name, data_loader_val in zip( predictions, output_folders, dataset_names, data_loaders_val): extra_args = dict( box_only=cfg.MODEL.RPN_ONLY, iou_types=iou_types, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, ) evaluate(dataset=data_loader_val.dataset, predictions=prediction, output_folder=output_folder, **extra_args) return 0
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '2' parser = argparse.ArgumentParser(description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default="/home/asd/Project/AirplaneDetection/Gliding-vertex-Trainer/gliding_vertex-master/configs/glide/dota.yaml", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--ckpt", help="The path to the checkpoint for test, default is the latest checkpoint.", default="/home/asd/Project/AirplaneDetection/Gliding-vertex-Trainer/exp_dota/0909/model_final.pth", ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 distributed = num_gpus > 1 if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group( backend="nccl", init_method="env://" ) synchronize() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("maskrcnn_benchmark", save_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) model = build_detection_model(cfg) model.to(cfg.MODEL.DEVICE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) ckpt = cfg.MODEL.WEIGHT if args.ckpt is None else args.ckpt _ = checkpointer.load(ckpt, use_latest=args.ckpt is None) """ # Initialize mixed-precision if necessary use_mixed_precision = cfg.DTYPE == 'float16' amp_handle = amp.init(enabled=use_mixed_precision, verbose=cfg.AMP_VERBOSE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) ckpt = cfg.MODEL.WEIGHT if args.ckpt is None else args.ckpt _ = checkpointer.load(ckpt, use_latest=args.ckpt is None) iou_types = ("bbox",) if cfg.MODEL.MASK_ON: iou_types = iou_types + ("segm",) if cfg.MODEL.KEYPOINT_ON: iou_types = iou_types + ("keypoints",) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): output_folder = os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=distributed) for output_folder, dataset_name, data_loader_val in zip(output_folders, dataset_names, data_loaders_val): inference( model, data_loader_val, dataset_name=dataset_name, iou_types=iou_types, box_only=False if cfg.MODEL.RETINANET_ON else cfg.MODEL.RPN_ONLY, device=cfg.MODEL.DEVICE, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, output_folder=output_folder, ) synchronize() """ from maskrcnn_benchmark.data.transforms.build import build_transforms from PIL import Image import torchvision.transforms.functional as F transform = build_transforms( cfg, is_train=False ) img_dir = "/home/asd/Mission/GaoFen/airplane_detection/data/train/train_val/val/images" res_dir = "/home/asd/Mission/GaoFen/airplane_detection/data/train/train_val/val/res" model.eval() # imgs = os.listdir( img_dir ) import glob imgs = glob.glob(img_dir+"/*.tif") for img in imgs: img_path = os.path.join( img_dir, img ) img_pil = Image.open( img_path ) # for i in range( 360 ): original_img = img_pil # original_img = F.rotate( img_pil, 45, expand=True ) origin_w, origin_h = original_img.size img, target = transform( original_img, None ) print(img.shape) img = img.view( (1, img.shape[0], img.shape[1], img.shape[2] ) ) h, w = img.shape[2:] if h % 32 != 0: new_h = ( h // 32 + 1 ) * 32 else: new_h = h if w % 32 != 0: new_w = ( w // 32 + 1 ) * 32 else: new_w = w ratio_w = 1. * new_w / w ratio_h = 1. * new_h / h padded_img = torch.zeros( (1, 3, new_h, new_w)).float() padded_img[:, :, :h, :w] = img prediction = model( padded_img.cuda() )[0] prediction = prediction.resize((origin_w * ratio_w, origin_h * ratio_h)) hboxes = prediction.bbox.cpu() rboxes = prediction.get_field( "rboxes" ).cpu() ratios = prediction.get_field( "ratios" ).cpu() scores = prediction.get_field( "scores" ).cpu() # labels = prediction.get_field( "labels" ).cpu() for rbox, ratio, score in zip( rboxes, ratios, scores ): print( rbox ) print( ratio, score ) h_idx = ratios > 0.8 # print(hboxes) h = hboxes[h_idx] hboxes_vtx = torch.stack( [h[:, 0], h[:, 1], h[:, 2], h[:, 1], h[:, 2], h[:, 3], h[:, 0], h[:, 3]] ).permute( 1, 0 ) rboxes[h_idx] = hboxes_vtx # rboxes = rboxes.data.numpy().astype( np.int32 ) rboxes = rboxes.data.numpy() keep = poly_nms( np.hstack( [rboxes, scores.cpu().data.numpy()[:, np.newaxis]] ).astype( np.double ), 0.1 ) rboxes = rboxes[keep].astype( np.int32 ) scores = scores[keep] hboxes = hboxes[keep] keep = np.where( scores > 0.6 ) rboxes = rboxes[keep] scores = scores[keep].tolist() hboxes = hboxes[keep] # rboxes = list( map( minAreaRect, rboxes ) ) if len( rboxes ) > 0: rboxes = np.vstack( rboxes ) else: rboxes = np.array( rboxes ) # vis( img_info["file_name"], rboxes ) # img = cv2.imread( original_img ) img = np.array( original_img.convert( "RGB" ) )[:, :, ::-1].copy() cv2.polylines( img, rboxes.reshape(-1, 4, 2).astype( np.int32 ), True, (0, 255, 255), thickness=2, lineType=cv2.LINE_AA ) filename = img_path.split( "/" )[-1] cv2.imwrite( "{}/{}".format( res_dir, filename ), img )
def imshow(img): plt.imshow(img[:, :, [2, 1, 0]]) plt.axis("off") plt.show() # raw image pil_image = Image.open( '/unsullied/sharefs/_research_video/VideoData/users/yejiacheng/pytorch/dataset/person_search/coco_format_sysu/test/s3289.jpg' ).convert("RGB") pil_image.save('a.jpg') # mask image config_file = "../configs/demo_mask_R_50_FPN.yaml" cfg.merge_from_file(config_file) cfg.merge_from_list(["MODEL.DEVICE", "cuda"]) coco_demo = COCODemo( cfg, min_image_size=800, confidence_threshold=0.7, ) # image = load("http://farm3.staticflickr.com/2469/3915380994_2e611b1779_z.jpg") image = np.array(pil_image)[:, :, [2, 1, 0]] # imshow(image) predictions = coco_demo.run_on_opencv_image(image) # imshow(predictions) im = Image.fromarray(predictions[:, :, [2, 1, 0]]) im.save('b.jpg') # detetction image config_file = "../configs/demo_faster_R_50_FPN.yaml"
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Webcam Demo") parser.add_argument( "--config-file", default= "configs/centermask/centermask_M_v2_FPN_lite_res600_ms_bs32_1x.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--weights", default="centermask-lite-M-v2-ms-bs32-1x.pth", metavar="FILE", help="path to the trained model", ) parser.add_argument( "--conf_th", type=float, default=0.2, help="confidence_threshold", ) parser.add_argument('--display_text', default=False, type=str2bool, help='Whether or not to display text (class [score])') parser.add_argument( '--display_scores', default=False, type=str2bool, help='Whether or not to display scores in addition to classes') parser.add_argument( "opts", help="Modify model config options using the command-line", default=None, nargs=argparse.REMAINDER, ) parser.add_argument('--input', type=str, default='datasets/coco/test2017', help='images to infer. Must not use with --image_dir') parser.add_argument('--output_dir', type=str, default='demo/results/CenterMask-Lite-M-v2', help='directory to save demo results') parser.add_argument('--salient', type=str, default='') parser.add_argument('--map_dir', type=str, default='') parser.add_argument('--selection', type=int, default=1) args = parser.parse_args() # load config from file and command-line arguments cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.MODEL.WEIGHT = args.weights cfg.freeze() # The following per-class thresholds are computed by maximizing # per-class f-measure in their precision-recall curve. # Please see compute_thresholds_for_classes() in coco_eval.py for details. # demo_im_names = os.listdir(args.images_dir) # # prepare object that handles inference plus adds predictions on top of image coco_demo = COCODemo(cfg, confidence_threshold=args.conf_th, display_text=args.display_text, display_scores=args.display_scores) # for im_name in demo_im_names: # img = cv2.imread(os.path.join(args.images_dir, im_name)) # if img is None: # continue # start_time = time.time() # composite = coco_demo.run_on_opencv_image(img) # print("{}\tinference time: {:.2f}s".format(im_name, time.time() - start_time)) # cv2.imshow(im_name, composite) # print("Press any keys to exit ...") # cv2.waitKey() # cv2.destroyAllWindows() if os.path.isfile(args.input): imglist = [args.input] else: imglist = glob(os.path.join(args.input, '*')) num_images = len(imglist) if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) for i in range(num_images): print('file', i) if os.path.splitext(imglist[i])[1] in ['.mp4', '.wmv', '.avi']: cap = cv2.VideoCapture(imglist[i]) image_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) image_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) # scale = get_target_scale(image_width, image_height, 800, 1333) video = cv2.VideoWriter( os.path.join(args.output_dir, os.path.basename(imglist[i])), cv2.VideoWriter_fourcc(*'mp4v'), 25.0, (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))) cnt = 0 while True: cnt += 1 # Capture frame-by-frame ret, img = cap.read() if ret: start_time = time.time() composite = coco_demo.run_on_opencv_image(img) print("{} frame \tinference time: {:.2f}s".format( cnt, time.time() - start_time)) video.write(composite) else: break if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() video.release() print('Result file number {} saved'.format(i)) elif os.path.splitext(imglist[i])[1] in [ '.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm' ]: img = cv2.imread(imglist[i]) assert img is not None im_name, _ = os.path.splitext(os.path.basename(imglist[i])) print(f"{im_name} processing...") start_time = time.time() composite = coco_demo.run_on_opencv_image(img, args) print("{}\tinference time: {:.2f}s".format( im_name, time.time() - start_time)) save_path = os.path.join(args.output_dir, f'{im_name}_result.jpg') cv2.imwrite(save_path, composite) else: continue
def main(): parser = argparse.ArgumentParser(description="PyTorch Object Detection") parser.add_argument( "--config-file", default="/home/mrvain/Workspace/test/FCOS_PLUS/configs/fcos/fcos_R_50_FPN_1x.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--weights", default="/home/mrvain/Workspace/test/fcos_r50.pth", metavar="FILE", help="path to the trained model", ) parser.add_argument( "--images-dir", default="/home/mrvain/Workspace/test/images", metavar="DIR", help="path to demo images directory", ) parser.add_argument( "--min-image-size", type=int, default=800, help="smallest size of the image to feed to the model", ) parser.add_argument( "opts", help="modify model config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.merge_from_list(["MODEL.DEVICE", "cpu"]) cfg.MODEL.WEIGHT = args.weights cfg.freeze() # The following per-class thresholds are computed by maximizing # per-class f-measure in their precision-recall curve. # Please see compute_thresholds_for_classes() in coco_eval.py for details. thresholds_for_classes = [ 0.23860901594161987, 0.24108672142028809, 0.2470853328704834, 0.2316885143518448, 0.2708061933517456, 0.23173952102661133, 0.31990334391593933, 0.21302376687526703, 0.20151866972446442, 0.20928964018821716, 0.3793887197971344, 0.2715213894844055, 0.2836397588253021, 0.26449233293533325, 0.1728038638830185, 0.314998596906662, 0.28575003147125244, 0.28987520933151245, 0.2727000117301941, 0.23306897282600403, 0.265937477350235, 0.32663893699645996, 0.27102580666542053, 0.29177549481391907, 0.2043062448501587, 0.24331751465797424, 0.20752687752246857, 0.22951272130012512, 0.22753854095935822, 0.2159966081380844, 0.1993938684463501, 0.23676514625549316, 0.20982342958450317, 0.18315598368644714, 0.2489681988954544, 0.24793922901153564, 0.287187397480011, 0.23045086860656738, 0.2462811917066574, 0.21191294491291046, 0.22845126688480377, 0.24365000426769257, 0.22687821090221405, 0.18365581333637238, 0.2035856395959854, 0.23478077352046967, 0.18431290984153748, 0.18184082210063934, 0.2708037495613098, 0.2268175482749939, 0.19970566034317017, 0.21832780539989471, 0.21120598912239075, 0.270445853471756, 0.189377561211586, 0.2101106345653534, 0.2112293541431427, 0.23484709858894348, 0.22701986134052277, 0.20732736587524414, 0.1953316181898117, 0.3237660229206085, 0.3078872859477997, 0.2881140112876892, 0.38746657967567444, 0.20038367807865143, 0.28123822808265686, 0.2588447630405426, 0.2796839773654938, 0.266757994890213, 0.3266656696796417, 0.25759157538414, 0.2578003704547882, 0.17009201645851135, 0.29051828384399414, 0.24002137780189514, 0.22378061711788177, 0.26134759187698364, 0.1730124056339264, 0.1857597529888153 ] image_filenames = os.listdir(args.images_dir) model = COCODemo( cfg, confidence_thresholds_for_classes=thresholds_for_classes, min_image_size=args.min_image_size ) for image_filename in image_filenames: img = cv2.imread(os.path.join(args.images_dir, image_filename)) if img is None: continue start_time = time.time() composite = model.run_on_opencv_image(img) print("{}\ttime: {:.2f}s".format(image_filename, time.time() - start_time)) cv2.imshow(image_filename, composite) print("Press any keys ...") cv2.waitKey() cv2.destroyAllWindows()
def main(): # Build a parser for arguments parser = argparse.ArgumentParser(description="Action Prediction Training") parser.add_argument( "--config_file", default= "/home/selfdriving/maskrcnn-benchmark/configs/e2e_custom_i3d_res50.yaml", metavar="FILE", help="path to maskrcnn_benchmark config file", type=str) # parser.add_argument('-train_split', type=str, default = '/home/selfdriving/I3D/data/4action_reason.json') parser.add_argument("--weight_decay", default=1e-4, help="Weight decay") parser.add_argument("opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER) parser.add_argument("--initLR", help="Initial learning rate", default=0.0001) parser.add_argument("--freeze", default=False, help="If freeze faster rcnn") parser.add_argument("--videoRoot", type=str, help="Directory to the videos", default="/home/selfdriving/mrcnn/bdd12k/") parser.add_argument('--frame_nb', type=int, default=8) parser.add_argument('--interval', type=int, default=2) # parser.add_argument("--featureRoot",type=str,help="Directory to the features",default="/home/selfdriving/I3D/features/") parser.add_argument( "--bboxRoot", type=str, help="Directory to the bbox groundtruth", default= "/home/selfdriving/mrcnn/output/inference/bdd100k_val/last_preds.pth") parser.add_argument( "--actionRoot", type=str, help="Directory to the action label groundtruth", default="/home/selfdriving/I3D/data/4action_reason.json") parser.add_argument("--batch_size", type=int, help="Batch Size", default=1) # parser.add_argument("--experiment",type=str,help="Give this experiment a name",default=str(datetime.datetime.now())) # parser.add_argument("--model_root",type=str,help="Directory to the trained model",default="/home/selfdriving/mrcnn/model_final_apt.pth") parser.add_argument("--val", action='store_true', default=False, help='Validation or not') parser.add_argument("--num_epoch", default=20, help="The number of epoch for training", type=int) parser.add_argument("--from_checkpoint", default=False, help="If we need load weights from checkpoint.") parser.add_argument("--checkpoint", default=".", help="The path to the checkpoint weights.", type=str) args = parser.parse_args() print(args) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() if torch.cuda.is_available(): print("CUDA device is available.") # output directory # outdir = cfg.OUTPUT_DIR # print("Save path:", outdir) # if outdir: # mkdir(outdir) # logger = setup_logger("training", outdir) train(cfg, args)
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default="", metavar="FILE", help="path to config file", type=str, ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--skip-test", dest="skip_test", help="Do not test the final model", action="store_true", ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() import random import torch.backends.cudnn as cudnn import numpy as np seed = 1 torch.manual_seed(seed) torch.cuda.manual_seed_all(seed + 1) random.seed(seed + 2) np.random.seed(seed + 3) print('use seed') cudnn.deterministic = True num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") synchronize() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_dir = os.path.join( cfg.OUTPUT_DIR, cfg.SUBDIR, 'GPU' + str(num_gpus) + '_LR' + str(cfg.SOLVER.BASE_LR)) if output_dir: mkdir(output_dir) logger = setup_logger("maskrcnn_benchmark", output_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(args) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) logger.info("Loaded configuration file {}".format(args.config_file)) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) model = train(cfg, args.local_rank, args.distributed) if not args.skip_test: run_test(cfg, model, args.distributed)
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default= "../configs/kidney/e2e_mask_rcnn_X_101_32x8d_FPN_1x_kidney_liver_using_pretrained_model.yaml", metavar="FILE", help="path to config file", type=str, ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--skip-test", dest="skip_test", help="Do not test the final model", action="store_true", ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) if cfg.OUTPUT_SUB_DIR: output_dir = os.path.join(cfg.OUTPUT_DIR, cfg.OUTPUT_SUB_DIR) else: now = time.localtime() time_dir_name = "%04d%02d%02d-%02d%02d%02d" % ( now.tm_year, now.tm_mon, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec) output_dir = os.path.join(cfg.OUTPUT_DIR, time_dir_name) cfg.merge_from_list(["OUTPUT_DIR", output_dir]) cfg.freeze() if output_dir: mkdir(output_dir) logger = setup_logger("maskrcnn_benchmark", output_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(args) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) logger.info("Loaded configuration file {}".format(args.config_file)) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) model = train(cfg, args.local_rank, args.distributed)
import os idx_no = 2 GPUS = ['0', '2', '3'] #os.environ['CUDA_VISIBLE_DEVICES']=GPUS[idx_no] #os.environ['CUDA_VISIBLE_DEVICES']="1" #config_file = "../configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml" #config_file = "../configs/caffe2/e2e_faster_rcnn_X_101_32x8d_FPN_1x_caffe2.yaml" #config_file = "../configs/e2e_mask_rcnn_X_101_32x8d_FPN_1x.yaml" config_file = "../configs/e2e_faster_rcnn_X_101_32x8d_FPN_1x.yaml" # update the config options with the config file cfg.merge_from_file(config_file) # manual override some options #cfg.merge_from_list(["MODEL.DEVICE", "cpu"]) cfg.merge_from_list(["MODEL.WEIGHT", "e2e_faster_rcnn_X_101_32x8d_FPN_1x.pth"]) coco_demo = COCODemo( cfg, min_image_size=800, confidence_threshold=0.50, ) # load image and then run prediction import cv2 #image = cv2.imread('/home/oytun/work/ActorConditionedAttentionMaps/data/AVA/segments/val/midframes/1j20qq1JyX4/1798.jpg') #image = cv2.imread('/home/oytun/work/maskrcnn_benchmark/maskrcnn-benchmark/demo/test_images/COCO_train2014_000000035110.jpg') #predictions = coco_demo.run_on_opencv_image(image) #cv2.imshow('preds',predictions) #cv2.waitKey(0) #predictions = coco_demo.compute_prediction(image)
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default="", metavar="FILE", help="path to config file", type=str, ) parser.add_argument("--local_rank", type=int, default=os.getenv('LOCAL_RANK', 0)) parser.add_argument("--max_steps", type=int, default=0, help="Override number of training steps in the config") parser.add_argument( "--skip-test", dest="skip_test", help="Do not test the final model", action="store_true", ) parser.add_argument("--fp16", help="Mixed precision training", action="store_true") parser.add_argument("--amp", help="Mixed precision training", action="store_true") parser.add_argument('--skip_checkpoint', default=False, action='store_true', help="Whether to save checkpoints") parser.add_argument( "--json-summary", help="Out file for DLLogger", default="dllogger.out", type=str, ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() args.fp16 = args.fp16 or args.amp num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") synchronize() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) # Redundant option - Override config parameter with command line input if args.max_steps > 0: cfg.SOLVER.MAX_ITER = args.max_steps if args.skip_checkpoint: cfg.SAVE_CHECKPOINT = False cfg.freeze() output_dir = cfg.OUTPUT_DIR if output_dir: mkdir(output_dir) logger = setup_logger("maskrcnn_benchmark", output_dir, get_rank()) if is_main_process(): dllogger.init(backends=[ dllogger.JSONStreamBackend(verbosity=dllogger.Verbosity.VERBOSE, filename=args.json_summary), dllogger.StdOutBackend(verbosity=dllogger.Verbosity.VERBOSE, step_format=format_step) ]) else: dllogger.init(backends=[]) dllogger.log(step="PARAMETER", data={"gpu_count": num_gpus}) # dllogger.log(step="PARAMETER", data={"environment_info": collect_env_info()}) dllogger.log(step="PARAMETER", data={"config_file": args.config_file}) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() dllogger.log(step="PARAMETER", data={"config": cfg}) if args.fp16: fp16 = True else: fp16 = False model, iters_per_epoch = train(cfg, args.local_rank, args.distributed, fp16, dllogger) if not args.skip_test: if not cfg.PER_EPOCH_EVAL: test_model(cfg, model, args.distributed, iters_per_epoch, dllogger)
def main(): mlperf_log.ROOT_DIR_MASKRCNN = os.path.dirname(os.path.abspath(__file__)) # mlperf_log.LOGGER.propagate = False parser = argparse.ArgumentParser( description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default= "/private/home/fmassa/github/detectron.pytorch/configs/rpn_r50.py", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument('--skip-test', dest='skip_test', help='Do not test the model', action='store_true') parser.add_argument("--fp16", action="store_true", help="Enable multi-precision training") parser.add_argument("--min_bbox_map", type=float, default=0.377, help="Target BBOX MAP") parser.add_argument("--min_mask_map", type=float, default=0.339, help="Target SEGM/MASK MAP") parser.add_argument("--seed", type=int, default=1, help="Seed") parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() args.distributed = (int(os.environ["WORLD_SIZE"]) > 1 if "WORLD_SIZE" in os.environ else False) if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") # to synchronize start of time torch.distributed.broadcast(torch.tensor([1], device="cuda"), 0) torch.cuda.synchronize() if torch.distributed.get_rank() == 0: # Setting logging file parameters for compliance logging os.environ["COMPLIANCE_FILE"] = '/MASKRCNN_complVv0.5.0_' + str( datetime.datetime.now()) mlperf_log.LOG_FILE = os.getenv("COMPLIANCE_FILE") mlperf_log._FILE_HANDLER = logging.FileHandler(mlperf_log.LOG_FILE) mlperf_log._FILE_HANDLER.setLevel(logging.DEBUG) mlperf_log.LOGGER.addHandler(mlperf_log._FILE_HANDLER) print_mlperf(key=mlperf_log.RUN_START) # Setting seed seed_tensor = torch.tensor(0, dtype=torch.float32, device=torch.device("cuda")) if torch.distributed.get_rank() == 0: # seed = int(time.time()) # random master seed, random.SystemRandom() uses /dev/urandom on Unix master_seed = random.SystemRandom().randint(0, 2**32 - 1) seed_tensor = torch.tensor(master_seed, dtype=torch.float32, device=torch.device("cuda")) torch.distributed.broadcast(seed_tensor, 0) master_seed = int(seed_tensor.item()) else: # Setting logging file parameters for compliance logging os.environ["COMPLIANCE_FILE"] = '/MASKRCNN_complVv0.5.0_' + str( datetime.datetime.now()) mlperf_log.LOG_FILE = os.getenv("COMPLIANCE_FILE") mlperf_log._FILE_HANDLER = logging.FileHandler(mlperf_log.LOG_FILE) mlperf_log._FILE_HANDLER.setLevel(logging.DEBUG) mlperf_log.LOGGER.addHandler(mlperf_log._FILE_HANDLER) print_mlperf(key=mlperf_log.RUN_START) # random master seed, random.SystemRandom() uses /dev/urandom on Unix master_seed = random.SystemRandom().randint(0, 2**32 - 1) args.seed = master_seed # random number generator with seed set to master_seed random_number_generator = random.Random(master_seed) print_mlperf(key=mlperf_log.RUN_SET_RANDOM_SEED, value=master_seed) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) if args.skip_test: cfg.DO_ONLINE_MAP_EVAL = False cfg.freeze() output_dir = cfg.OUTPUT_DIR if output_dir: mkdir(output_dir) #logger = setup_logger("maskrcnn_benchmark", output_dir, args.local_rank) logger = setup_logger("maskrcnn_benchmark", None, args.local_rank) logger.info(args) # generate worker seeds, one seed for every distributed worker worker_seeds = generate_seeds( random_number_generator, torch.distributed.get_world_size() if torch.distributed.is_initialized() else 1) # todo sharath what if CPU # broadcast seeds from rank=0 to other workers worker_seeds = broadcast_seeds(worker_seeds, device='cuda') # Setting worker seeds logger.info("Worker {}: Setting seed {}".format( args.local_rank, worker_seeds[args.local_rank])) torch.manual_seed(worker_seeds[args.local_rank]) logger.info("Loaded configuration file {}".format(args.config_file)) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) model = train(cfg, random_number_generator, args.local_rank, args.distributed, args, args.fp16) print_mlperf(key=mlperf_log.RUN_FINAL)
def main(): parser = argparse.ArgumentParser(description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default="/home/sgiit/disk_1T/sgiit/Pengming_Feng/GitClone/ship_detection_optical/maskrcnn-benchmark/configs/ship_detection_net/ship_detection_R_101_FPN_1x.yaml", metavar="FILE", help="path to config file", type=str, ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--skip-test", dest="skip_test", help="Do not test the final model", action="store_true", ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group( backend="nccl", init_method="env://" ) synchronize() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_dir = cfg.OUTPUT_DIR if output_dir: mkdir(output_dir) logger = setup_logger("maskrcnn_benchmark", output_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(args) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) logger.info("Loaded configuration file {}".format(args.config_file)) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) output_config_path = os.path.join(cfg.OUTPUT_DIR, 'config.yml') logger.info("Saving config into: {}".format(output_config_path)) # save overloaded model config in the output directory save_config(cfg, output_config_path) model = train(cfg, args.local_rank, args.distributed) if not args.skip_test: run_test(cfg, model, args.distributed)
from maskrcnn_benchmark.config import cfg from predictor import COCODemo import cv2 config_file = "e2e_faster_rcnn_X_101_32x8d_FPN_1x_visdrone.yaml" # update the config options with the config file cfg.merge_from_file(config_file) # manual override some options #cfg.merge_from_list(["MODEL.DEVICE", "cpu"]) cfg.merge_from_list(["MODEL.WEIGHT", "visdrone_model_0360000.pth"]) coco_demo = COCODemo( cfg, min_image_size=800, confidence_threshold=0.7, ) # load image and then run prediction image = cv2.imread('visdrone_test_img_0000001_02999_d_0000005.jpg') predictions = coco_demo.run_on_opencv_image(image) #cv2.imwrite('drone_res.jpg', predictions) cv2.imshow('Predictions', predictions) cv2.waitKey(0)
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default="configs/e2e_faster_rcnn_R_50_FPN_1x.yaml", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "--ckpt", help= "The path to the checkpoint for test, default is the latest checkpoint.", default=None, ) parser.add_argument('--num_iteration', dest='num_iteration', help='Specify which weight to load', default=-1, type=int) parser.add_argument('--object_thres', dest='object_thres', help='Object threshold', default=0.1, type=float) # used to be 0.4 or 0.05 parser.add_argument('--human_thres', dest='human_thres', help='Human threshold', default=0.8, type=float) parser.add_argument('--prior_flag', dest='prior_flag', help='whether use prior_flag', default=1, type=int) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 distributed = num_gpus > 1 and torch.cuda.is_available() if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") synchronize() ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) # DATA_DIR = os.path.abspath(os.path.join(ROOT_DIR, 'Data')) args.config_file = os.path.join(ROOT_DIR, args.config_file) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("DRG", save_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) model = build_detection_model(cfg) # model.to(cfg.MODEL.DEVICE) device = torch.device( "cuda") if torch.cuda.is_available() else torch.device("cpu") model.to(device) # Initialize mixed-precision if necessary use_mixed_precision = cfg.DTYPE == 'float16' amp_handle = amp.init(enabled=use_mixed_precision, verbose=cfg.AMP_VERBOSE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) if args.num_iteration != -1: args.ckpt = os.path.join(cfg.OUTPUT_DIR, 'model_%07d.pth' % args.num_iteration) ckpt = cfg.MODEL.WEIGHT if args.ckpt is None else args.ckpt logger.info("Testing checkpoint {}".format(ckpt)) _ = checkpointer.load(ckpt, use_latest=args.ckpt is None) # iou_types = ("bbox",) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): if args.num_iteration != -1: output_folder = os.path.join(cfg.OUTPUT_DIR, "inference_ho", dataset_name, "model_%07d" % args.num_iteration) else: output_folder = os.path.join(cfg.OUTPUT_DIR, "inference_ho", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder opt = {} opt['word_dim'] = 300 for output_folder, dataset_name in zip(output_folders, dataset_names): data = DatasetCatalog.get(dataset_name) data_args = data["args"] im_dir = data_args['im_dir'] test_detection = pickle.load(open(data_args['test_detection_file'], "rb"), encoding='latin1') prior_mask = pickle.load(open(data_args['prior_mask'], "rb"), encoding='latin1') action_dic = json.load(open(data_args['action_index'])) action_dic_inv = {y: x for x, y in action_dic.items()} vcoco_test_ids = open(data_args['vcoco_test_ids_file'], 'r') test_image_id_list = [int(line.rstrip()) for line in vcoco_test_ids] vcocoeval = VCOCOeval(data_args['vcoco_test_file'], data_args['ann_file'], data_args['vcoco_test_ids_file']) word_embeddings = pickle.load(open(data_args['word_embedding_file'], "rb"), encoding='latin1') output_file = os.path.join(output_folder, 'detection.pkl') output_dict_file = os.path.join( output_folder, 'detection_app_{}_new.pkl'.format(dataset_name)) logger.info("Output will be saved in {}".format(output_file)) logger.info("Start evaluation on {} dataset({} images).".format( dataset_name, len(test_image_id_list))) run_test(model, dataset_name=dataset_name, im_dir=im_dir, test_detection=test_detection, word_embeddings=word_embeddings, test_image_id_list=test_image_id_list, prior_mask=prior_mask, action_dic_inv=action_dic_inv, output_file=output_file, output_dict_file=output_dict_file, object_thres=args.object_thres, human_thres=args.human_thres, prior_flag=args.prior_flag, device=device, cfg=cfg) synchronize() vcocoeval._do_eval(output_file, ovr_thresh=0.5)
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default= "/private/home/fmassa/github/detectron.pytorch_v2/configs/e2e_faster_rcnn_R_50_C4_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--json-file", default="", metavar="FILE", help="path to prediction bbox json file", ) # parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() # num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 # distributed = num_gpus > 1 # if distributed: # torch.cuda.set_device(args.local_rank) # torch.distributed.init_process_group( # backend="nccl", init_method="env://" # ) # synchronize() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("maskrcnn_benchmark", save_dir, get_rank()) # logger.info("Using {} GPUs".format(num_gpus)) # logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) # model = build_detection_model(cfg) # model.to(cfg.MODEL.DEVICE) output_dir = cfg.OUTPUT_DIR # checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) # _ = checkpointer.load(cfg.MODEL.WEIGHT) iou_types = ("bbox", ) # if cfg.MODEL.MASK_ON: # iou_types = iou_types + ("segm",) # if cfg.MODEL.KEYPOINT_ON: # iou_types = iou_types + ("keypoints",) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): output_folder = os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=False) for output_folder, dataset_name, data_loader_val in zip( output_folders, dataset_names, data_loaders_val): # inference( # model, # data_loader_val, # dataset_name=dataset_name, # iou_types=iou_types, # box_only=False if cfg.MODEL.FCOS_ON or cfg.MODEL.RETINANET_ON else cfg.MODEL.RPN_ONLY, # device=cfg.MODEL.DEVICE, # expected_results=cfg.TEST.EXPECTED_RESULTS, # expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, # output_folder=output_folder, # ) # extra_args = dict( # box_only=False, # iou_types=iou_types, # expected_results=cfg.TEST.EXPECTED_RESULTS, # expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, # ) dataset = data_loader_val.dataset # evaluate(dataset=dataset, # predictions=predictions, # output_folder=output_folder, # only_human=True, # **extra_args) do_coco_json_evaluation( dataset=dataset, json_file=args.json_file, box_only=False, output_folder=output_folder, iou_types=iou_types, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL) synchronize()
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Image Dir Demo") parser.add_argument( "--image-dir", required=True, help="path to image dir", ) parser.add_argument( "--output-dir", required=True, help="path to output dir", ) parser.add_argument( "--config-file", default="configs/e2e_faster_rcnn_R_50_FPN_1x.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--confidence-threshold", type=float, default=0.7, help="Minimum score for the prediction to be shown", ) parser.add_argument( "--templete", default='coco', help="Categories templete for pretty print", ) parser.add_argument( "--min-image-size", type=int, default=800, help="Smallest size of the image to feed to the model. " "Model was trained with 800, which gives best results", ) parser.add_argument( "--show-mask-heatmaps", dest="show_mask_heatmaps", help="Show a heatmap probability for the top masks-per-dim masks", action="store_true", ) parser.add_argument( "--masks-per-dim", type=int, default=2, help="Number of heatmaps per dimension to show", ) parser.add_argument( "opts", help="Modify model config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() # load config from file and command-line arguments cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() # prepare object that handles inference plus adds predictions on top of image coco_demo = COCODemo( cfg, confidence_threshold=args.confidence_threshold, show_mask_heatmaps=args.show_mask_heatmaps, masks_per_dim=args.masks_per_dim, min_image_size=args.min_image_size, categories_templete=args.templete, ) annotation_dir = os.path.join(args.output_dir, 'annotations') vis_dir = os.path.join(args.output_dir, 'vis') if not os.path.exists(annotation_dir): os.makedirs(annotation_dir) # os.makedirs(vis_dir) for f in os.listdir(args.image_dir): if f.endswith('.png') or f.endswith('.jpg') or f.endswith('.jpeg'): image_fn = os.path.join(args.image_dir, f) img = cv2.imread(image_fn) start_time = time.time() prediction = coco_demo.compute_prediction(img) json_str = coco_demo.prediction_to_json_str(f, prediction) ofs = open(os.path.join(annotation_dir, f + '.json'), 'w') ofs.write(json_str) ofs.close() composite = coco_demo.run_on_opencv_image(img) print("Time: {:.2f} s / img".format(time.time() - start_time)) cv2.imshow("COCO detections", composite) # cv2.imwrite(os.path.join(vis_dir, f+'.png'), composite) if cv2.waitKey(1) == 27: break # esc to quit cv2.destroyAllWindows()
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Webcam Demo") parser.add_argument( "--config-file", default="../configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--confidence-threshold", type=float, default=0.7, help="Minimum score for the prediction to be shown", ) parser.add_argument( "--min-image-size", type=int, default=224, help="Smallest size of the image to feed to the model. " "Model was trained with 800, which gives best results", ) parser.add_argument( "--show-mask-heatmaps", dest="show_mask_heatmaps", help="Show a heatmap probability for the top masks-per-dim masks", action="store_true", ) parser.add_argument( "--masks-per-dim", type=int, default=2, help="Number of heatmaps per dimension to show", ) parser.add_argument( "opts", help="Modify model config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() # load config from file and command-line arguments cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() # prepare object that handles inference plus adds predictions on top of image coco_demo = COCODemo( cfg, confidence_threshold=args.confidence_threshold, show_mask_heatmaps=args.show_mask_heatmaps, masks_per_dim=args.masks_per_dim, min_image_size=args.min_image_size, ) cam = cv2.VideoCapture(0) while True: start_time = time.time() ret_val, img = cam.read() composite = coco_demo.run_on_opencv_image(img) print("fps: {:.2f} s".format(1 / (time.time() - start_time))) cv2.imshow("COCO detections", composite) if cv2.waitKey(1) == 27: break # esc to quit cv2.destroyAllWindows()
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Webcam Demo") parser.add_argument( "--config-file", default="../configs/caffe2/keypoints_R_101_FPN.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--confidence-threshold", type=float, default=0.7, help="Minimum score for the prediction to be shown", ) parser.add_argument( "--min-image-size", type=int, default=224, help="Smallest size of the image to feed to the model. " "Model was trained with 800, which gives best results", ) parser.add_argument( "--show-mask-heatmaps", dest="show_mask_heatmaps", help="Show a heatmap probability for the top masks-per-dim masks", action="store_true", ) parser.add_argument( "--masks-per-dim", type=int, default=2, help="Number of heatmaps per dimension to show", ) parser.add_argument( "opts", help="Modify model config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() # load config from file and command-line arguments cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() # prepare object that handles inference plus adds predictions on top of image coco_demo = COCODemo( cfg, confidence_threshold=args.confidence_threshold, show_mask_heatmaps=args.show_mask_heatmaps, masks_per_dim=args.masks_per_dim, min_image_size=args.min_image_size, ) # results = [] print("testing ...") val_rootpath = './../datasets/linemod/ape_train' with open('val.txt', 'r') as fp: val_imgs = fp.readlines() # print(val_imgs) fp.close() for imgname in val_imgs: per_dict = {} imgname = imgname.replace('\n', '').split('/')[-1] imgpath = os.path.join(val_rootpath, imgname) print(imgname) img = cv2.imread(imgpath) # print(img) _, box, score, kpts = coco_demo.run_on_opencv_image(img) np_box = box.cpu().numpy() np_score = score.cpu().numpy() per_dict[imgname] = [ np_box.tolist(), np_score.tolist(), kpts.tolist() ] results.append(per_dict) # to save results json_dict = {} json_dict["ape"] = results with open('./result.json', 'w') as f: json.dump(json_dict, f) f.close() return True
"--ckpt", help= "The path to the checkpoint for test, default is the latest checkpoint.", default=None, ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_name = 'BBAM_Mask_RCNN_logs_mcg85' output_folder = '%s/inference/voc_2012_val_cocostyle/' % output_name extra_args = dict( box_only=False, iou_types=["bbox", "segm"], expected_results=[], expected_results_sigma_tol=4, ) dataset_names = cfg.DATASETS.TEST data_loaders = make_data_loader(cfg, is_train=False, is_distributed=False)[0] dataset = data_loaders.dataset print(len(dataset))
def main(): # Build a parser for arguments parser = argparse.ArgumentParser(description="Action Prediction Training") parser.add_argument( "--config-file", default="/home/SelfDriving/maskrcnn/maskrcnn-benchmark/configs/baseline.yaml", metavar="FILE", help="path to maskrcnn_benchmark config file", type=str, ) parser.add_argument( "--is_cat", default=False, help="If we use concatenation on object features", type=bool, ) parser.add_argument( "--side", default=False, help="If we use side task", type=bool, ) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) parser.add_argument( "--imageroot", type=str, help="Directory to the images", default="/data6/SRIP19_SelfDriving/bdd12k/data1/" ) parser.add_argument( "--gtroot", type=str, help="Directory to the groundtruth", default="/data6/SRIP19_SelfDriving/bdd12k/annotations/12k_gt_val_5_actions.json" ) parser.add_argument( "--reasonroot", type=str, help="Directory to the reason gt", default="/data6/SRIP19_SelfDriving/bdd12k/annotations/val_reason_img.json" ) parser.add_argument( "--imWidth", type=int, help="Crop to width", default=1280 ) parser.add_argument( "--imHeight", type=int, help="Crop to height", default=720 ) parser.add_argument( "--batch_size", type=int, help="Batch Size", default=1 ) parser.add_argument( "--is_savemaps", type=bool, help="Whether save attention maps", default=False ) parser.add_argument( "--model_root", type=str, help="Directory to the trained model", default="/data6/SRIP19_SelfDriving/bdd12k/Outputs/08_28_side_v1/finetune/net_10.pth" ) parser.add_argument( "--output_dir", type=str, help="Directory to the trained model", default="/data6/SRIP19_SelfDriving/bdd12k/Outputs/08_28_side_v1/" ) args = parser.parse_args() print(args) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() if torch.cuda.is_available(): print("CUDA device is available.") # output directory outdir = cfg.OUTPUT_DIR print("Save path:", outdir) if outdir: mkdir(outdir) # logger = setup_logger("training", outdir) test(cfg, args)
pylab.rcParams['figure.figsize'] = 20 * d, 12 * d pylab.rc('image', interpolation='bilinear') from maskrcnn_benchmark.config import cfg from maskrcnn_benchmark.data.datasets.coco import COCODataset from predictor import COCODemo from maskrcnn_benchmark.structures.boxlist_ops import boxlist_nms from matplotlib.pyplot import imshow from maskrcnn_benchmark.data.datasets.evaluation.coco import coco_eval from maskrcnn_benchmark.data.datasets.coco import COCODataset config_file = "../configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml" # update the config options with the config file cfg.merge_from_file(config_file) # manual override some options cfg.merge_from_list(["MODEL.DEVICE", "cuda:0"]) def re_detect2(img, preds, min_score=0, max_score=1, inflation_factor=1, is_abs=False, min_keep_iou=.5): scores = preds.extra_fields['scores'] labels = preds.extra_fields['labels'].numpy() masking_color = 128 masked_images = [] new_dets_map = {} for ibox, score in tqdm(enumerate(scores), total=len(preds)):
def main(): parser = argparse.ArgumentParser( description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default="/configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 distributed = num_gpus > 1 if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("maskrcnn_benchmark", save_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) model = build_detection_model(cfg) model.to(cfg.MODEL.DEVICE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) _ = checkpointer.load(cfg.MODEL.WEIGHT) iou_types = ("bbox", ) if cfg.MODEL.MASK_ON: iou_types = iou_types + ("segm", ) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): output_folder = os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=distributed) for output_folder, dataset_name, data_loader_val in zip( output_folders, dataset_names, data_loaders_val): inference( model, data_loader_val, dataset_name=dataset_name, iou_types=iou_types, box_only=cfg.MODEL.RPN_ONLY, device=cfg.MODEL.DEVICE, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, output_folder=output_folder, ) synchronize()
def main(): mlperf_log.ROOT_DIR_MASKRCNN = os.path.dirname(os.path.abspath(__file__)) parser = argparse.ArgumentParser( description="PyTorch Object Detection Training") parser.add_argument( "--config-file", default="", metavar="FILE", help="path to config file", type=str, ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int( os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = num_gpus > 1 if is_main_process: # Setting logging file parameters for compliance logging os.environ["COMPLIANCE_FILE"] = './MASKRCNN_complVv0.5.0_' + str( datetime.datetime.now()) mlperf_log.LOG_FILE = os.getenv("COMPLIANCE_FILE") mlperf_log._FILE_HANDLER = logging.FileHandler(mlperf_log.LOG_FILE) mlperf_log._FILE_HANDLER.setLevel(logging.DEBUG) mlperf_log.LOGGER.addHandler(mlperf_log._FILE_HANDLER) if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") synchronize() print_mlperf(key=mlperf_log.RUN_START) # setting seeds - needs to be timed, so after RUN_START if is_main_process(): master_seed = random.SystemRandom().randint(0, 2**32 - 1) seed_tensor = torch.tensor(master_seed, dtype=torch.float32, device=torch.device("cuda")) else: seed_tensor = torch.tensor(0, dtype=torch.float32, device=torch.device("cuda")) torch.distributed.broadcast(seed_tensor, 0) master_seed = int(seed_tensor.item()) else: print_mlperf(key=mlperf_log.RUN_START) # random master seed, random.SystemRandom() uses /dev/urandom on Unix master_seed = random.SystemRandom().randint(0, 2**32 - 1) # actually use the random seed args.seed = master_seed # random number generator with seed set to master_seed random_number_generator = random.Random(master_seed) print_mlperf(key=mlperf_log.RUN_SET_RANDOM_SEED, value=master_seed) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_dir = cfg.OUTPUT_DIR if output_dir: mkdir(output_dir) logger = setup_logger("maskrcnn_benchmark", output_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(args) # generate worker seeds, one seed for every distributed worker worker_seeds = generate_seeds( random_number_generator, torch.distributed.get_world_size() if torch.distributed.is_initialized() else 1) # todo sharath what if CPU # broadcast seeds from rank=0 to other workers worker_seeds = broadcast_seeds(worker_seeds, device='cuda') # Setting worker seeds logger.info("Worker {}: Setting seed {}".format( args.local_rank, worker_seeds[args.local_rank])) torch.manual_seed(worker_seeds[args.local_rank]) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) logger.info("Loaded configuration file {}".format(args.config_file)) with open(args.config_file, "r") as cf: config_str = "\n" + cf.read() logger.info(config_str) logger.info("Running with config:\n{}".format(cfg)) model = train(cfg, args.local_rank, args.distributed) print_mlperf(key=mlperf_log.RUN_FINAL)
def main(): parser = argparse.ArgumentParser(description="PyTorch Object Detection Inference") parser.add_argument( "--config-file", default="/private/home/fmassa/github/detectron.pytorch_v2/configs/e2e_faster_rcnn_R_50_C4_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument("--local_rank", type=int, default=0) parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 distributed = num_gpus > 1 if distributed: torch.cuda.set_device(args.local_rank) torch.distributed.deprecated.init_process_group( backend="nccl", init_method="env://" ) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() save_dir = "" logger = setup_logger("maskrcnn_benchmark", save_dir, get_rank()) logger.info("Using {} GPUs".format(num_gpus)) logger.info(cfg) logger.info("Collecting env info (might take some time)") logger.info("\n" + collect_env_info()) model = build_detection_model(cfg) model.to(cfg.MODEL.DEVICE) output_dir = cfg.OUTPUT_DIR checkpointer = DetectronCheckpointer(cfg, model, save_dir=output_dir) _ = checkpointer.load(cfg.MODEL.WEIGHT) iou_types = ("bbox",) if cfg.MODEL.MASK_ON: iou_types = iou_types + ("segm",) output_folders = [None] * len(cfg.DATASETS.TEST) dataset_names = cfg.DATASETS.TEST if cfg.OUTPUT_DIR: for idx, dataset_name in enumerate(dataset_names): output_folder = os.path.join(cfg.OUTPUT_DIR, "inference", dataset_name) mkdir(output_folder) output_folders[idx] = output_folder data_loaders_val = make_data_loader(cfg, is_train=False, is_distributed=distributed) for output_folder, dataset_name, data_loader_val in zip(output_folders, dataset_names, data_loaders_val): inference( model, data_loader_val, dataset_name=dataset_name, iou_types=iou_types, box_only=cfg.MODEL.RPN_ONLY, device=cfg.MODEL.DEVICE, expected_results=cfg.TEST.EXPECTED_RESULTS, expected_results_sigma_tol=cfg.TEST.EXPECTED_RESULTS_SIGMA_TOL, output_folder=output_folder, ) synchronize()
def main(): parser = argparse.ArgumentParser(description="PyTorch Object Detection Webcam Demo") parser.add_argument( "--config-file", default="../configs/caffe2/e2e_mask_rcnn_R_50_FPN_1x_caffe2.yaml", metavar="FILE", help="path to config file", ) parser.add_argument( "--confidence-threshold", type=float, default=0.7, help="Minimum score for the prediction to be shown", ) parser.add_argument( "--min-image-size", type=int, default=224, help="Smallest size of the image to feed to the model. " "Model was trained with 800, which gives best results", ) parser.add_argument( "--show-mask-heatmaps", dest="show_mask_heatmaps", help="Show a heatmap probability for the top masks-per-dim masks", action="store_true", ) parser.add_argument( "--masks-per-dim", type=int, default=2, help="Number of heatmaps per dimension to show", ) parser.add_argument( "opts", help="Modify model config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() # load config from file and command-line arguments cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() # prepare object that handles inference plus adds predictions on top of image coco_demo = COCODemo( cfg, confidence_threshold=args.confidence_threshold, show_mask_heatmaps=args.show_mask_heatmaps, masks_per_dim=args.masks_per_dim, min_image_size=args.min_image_size, ) cam = cv2.VideoCapture(0) while True: start_time = time.time() ret_val, img = cam.read() composite = coco_demo.run_on_opencv_image(img) print("Time: {:.2f} s / img".format(time.time() - start_time)) cv2.imshow("COCO detections", composite) if cv2.waitKey(1) == 27: break # esc to quit cv2.destroyAllWindows()