def _test_model(self, config_path, inference_func, batch=1): model = model_zoo.get(config_path, trained=True) image = get_sample_coco_image() inputs = tuple(image.clone() for _ in range(batch)) wrapper = TracingAdapter(model, inputs, inference_func) wrapper.eval() with torch.no_grad(): # trace with smaller images, and the trace must still work trace_inputs = tuple( nn.functional.interpolate( image, scale_factor=random.uniform(0.5, 0.7)) for _ in range(batch)) traced_model = torch.jit.trace(wrapper, trace_inputs) outputs = inference_func(model, *inputs) traced_outputs = wrapper.outputs_schema(traced_model(*inputs)) if batch > 1: for output, traced_output in zip(outputs, traced_outputs): assert_instances_allclose(output, traced_output, size_as_tensor=True) else: assert_instances_allclose(outputs, traced_outputs, size_as_tensor=True)
def _test_model(self, config_path, inference_func): model = model_zoo.get(config_path, trained=True) image = get_sample_coco_image() class Wrapper(nn.ModuleList): # a wrapper to make the model traceable def forward(self, image): outputs = inference_func(self[0], image) flattened_outputs, schema = flatten_to_tuple(outputs) if not hasattr(self, "schema"): self.schema = schema return flattened_outputs def rebuild(self, flattened_outputs): return self.schema(flattened_outputs) wrapper = Wrapper([model]) wrapper.eval() with torch.no_grad(), patch_builtin_len(): small_image = nn.functional.interpolate(image, scale_factor=0.5) # trace with a different image, and the trace must still work traced_model = torch.jit.trace(wrapper, (small_image,)) output = inference_func(model, image) traced_output = wrapper.rebuild(traced_model(image)) assert_instances_allclose(output, traced_output, size_as_tensor=True)
def test_detectron2_retinanet(self): width = 320 height = 320 # Load model model = model_zoo.get("COCO-Detection/retinanet_R_50_FPN_1x.yaml", trained=True) model.eval() # Prepare input tensor img = cv.resize(self.test_img, (width, height)) inp = img.transpose(2, 0, 1).astype(np.float32) # Get reference prediction ref = model([{'image': torch.tensor(inp)}]) ref = ref[0]['instances'].get_fields() ref_boxes = [] for box, score, class_idx in zip(ref['pred_boxes'], ref['scores'], ref['pred_classes']): xmin, ymin, xmax, ymax = box ref_boxes.append([xmin, ymin, xmax, ymax]) if score > 0.45: cv.rectangle(img, (xmin, ymin), (xmax, ymax), color=(0, 180, 255), thickness=3) # Convert model to OpenVINO IR mo_pytorch.convert(model, input_shape=[1, 3, height, width], model_name='retinanet_R_50_FPN_1x') # Get OpenVINO prediction net = self.ie.read_network('retinanet_R_50_FPN_1x.xml', 'retinanet_R_50_FPN_1x.bin') exec_net = self.ie.load_network(net, 'CPU') outs = exec_net.infer({'input': inp.reshape(1, 3, height, width)}) ie_detections = next(iter(outs.values())) ie_detections = ie_detections.reshape(-1, 7) for det in ie_detections: conf = det[2] if conf > 0.45: xmin, ymin, xmax, ymax = det[3:] cv.rectangle(img, (xmin, ymin), (xmax, ymax), color=(210, 9, 179)) # Uncomment to visualize detections # cv.imshow('RetinaNet (Detectron2)', img) # cv.waitKey() self.normAssertDetections(ref['pred_classes'], ref['scores'], ref_boxes, ie_detections[:, 1], ie_detections[:, 2], ie_detections[:, 3:])
def _test_model(self, config_path, inference_func): model = model_zoo.get(config_path, trained=True) image = get_sample_coco_image() wrapper = TracingAdapter(model, image, inference_func) wrapper.eval() with torch.no_grad(): small_image = nn.functional.interpolate(image, scale_factor=0.5) # trace with a different image, and the trace must still work traced_model = torch.jit.trace(wrapper, (small_image,)) output = inference_func(model, image) traced_output = wrapper.outputs_schema(traced_model(image)) assert_instances_allclose(output, traced_output, size_as_tensor=True)
def _test_model(self, config_path, WrapperCls): # TODO wrapper should be handled by export API in the future model = model_zoo.get(config_path, trained=True) image = get_sample_coco_image() model = WrapperCls([model]) model.eval() with torch.no_grad(), patch_builtin_len(): small_image = nn.functional.interpolate(image, scale_factor=0.5) # trace with a different image, and the trace must still work traced_model = torch.jit.trace(model, (small_image, )) output = WrapperCls.convert_output(model(image)) traced_output = WrapperCls.convert_output(traced_model(image)) assert_instances_allclose(output, traced_output)
def _test_retinanet_model(self, config_path): model = model_zoo.get(config_path, trained=True) model.eval() fields = { "pred_boxes": Boxes, "scores": Tensor, "pred_classes": Tensor, } script_model = export_torchscript_with_instances(model, fields) img = get_sample_coco_image() inputs = [{"image": img}] with torch.no_grad(): instance = model(inputs)[0]["instances"] scripted_instance = convert_scripted_instances(script_model(inputs)[0]) scripted_instance = detector_postprocess(scripted_instance, img.shape[1], img.shape[2]) assert_instances_allclose(instance, scripted_instance)
def _test_rcnn_model(self, config_path): model = model_zoo.get(config_path, trained=True) model.eval() fields = { "proposal_boxes": Boxes, "objectness_logits": Tensor, "pred_boxes": Boxes, "scores": Tensor, "pred_classes": Tensor, "pred_masks": Tensor, } script_model = export_torchscript_with_instances(model, fields) inputs = [{"image": get_sample_coco_image()}] with torch.no_grad(): instance = model.inference(inputs, do_postprocess=False)[0] scripted_instance = script_model.inference(inputs, do_postprocess=False)[0] assert_instances_allclose(instance, scripted_instance)
def _test_model(self, config_path, device="cpu"): # requires extra dependencies from detectron2.export import Caffe2Model, add_export_config, Caffe2Tracer cfg = model_zoo.get_config(config_path) add_export_config(cfg) cfg.MODEL.DEVICE = device model = model_zoo.get(config_path, trained=True, device=device) inputs = [{"image": get_sample_coco_image()}] c2_model = Caffe2Tracer(cfg, model, copy.deepcopy(inputs)).export_caffe2() with tempfile.TemporaryDirectory(prefix="detectron2_unittest") as d: c2_model.save_protobuf(d) c2_model.save_graph(os.path.join(d, "test.svg"), inputs=copy.deepcopy(inputs)) c2_model = Caffe2Model.load_protobuf(d) c2_model(inputs)[0]["instances"]
def _test_model(self, config_path, device="cpu"): cfg = model_zoo.get_config(config_path) cfg.MODEL.DEVICE = device model = model_zoo.get(config_path, trained=True, device=device) inputs = [{"image": get_sample_coco_image()}] tracer = Caffe2Tracer(cfg, model, copy.deepcopy(inputs)) with tempfile.TemporaryDirectory(prefix="detectron2_unittest") as d: if not os.environ.get("CI"): # This requires onnx, which is not yet available on public CI c2_model = tracer.export_caffe2() c2_model.save_protobuf(d) c2_model.save_graph(os.path.join(d, "test.svg"), inputs=copy.deepcopy(inputs)) c2_model = Caffe2Model.load_protobuf(d) c2_model(inputs)[0]["instances"] ts_model = tracer.export_torchscript() ts_model.save(os.path.join(d, "model.ts"))
def _test_rcnn_model(self, config_path): model = model_zoo.get(config_path, trained=True) model.eval() fields = { "proposal_boxes": Boxes, "objectness_logits": Tensor, "pred_boxes": Boxes, "scores": Tensor, "pred_classes": Tensor, "pred_masks": Tensor, } script_model = scripting_with_instances(model, fields) # Test that batch inference with different shapes are supported image = get_sample_coco_image() small_image = nn.functional.interpolate(image, scale_factor=0.5) inputs = [{"image": image}, {"image": small_image}] with torch.no_grad(): instance = model.inference(inputs, do_postprocess=False)[0] scripted_instance = script_model.inference(inputs, do_postprocess=False)[0] assert_instances_allclose(instance, scripted_instance)
def _test_model(self, config_path, inference_func, batch=1): model = model_zoo.get(config_path, trained=True) image = get_sample_coco_image() inputs = tuple(image.clone() for _ in range(batch)) wrapper = TracingAdapter(model, inputs, inference_func) wrapper.eval() with torch.no_grad(): # trace with smaller images, and the trace must still work trace_inputs = tuple( nn.functional.interpolate(image, scale_factor=random.uniform(0.5, 0.7)) for _ in range(batch) ) traced_model = torch.jit.trace(wrapper, trace_inputs) testing_devices = self._get_device_casting_test_cases(model) # save and load back the model in order to show traceback of TorchScript with tempfile.TemporaryDirectory(prefix="detectron2_test") as d: basename = "model" jitfile = f"{d}/{basename}.jit" torch.jit.save(traced_model, jitfile) traced_model = torch.jit.load(jitfile) if any(device and "cuda" in device for device in testing_devices): self._check_torchscript_no_hardcoded_device(jitfile, d, "cuda") for device in testing_devices: print(f"Testing casting to {device} for inference (traced on {model.device}) ...") with torch.no_grad(): outputs = inference_func(copy.deepcopy(model).to(device), *inputs) traced_outputs = wrapper.outputs_schema(traced_model.to(device)(*inputs)) if batch > 1: for output, traced_output in zip(outputs, traced_outputs): assert_instances_allclose(output, traced_output, size_as_tensor=True) else: assert_instances_allclose(outputs, traced_outputs, size_as_tensor=True)
if __name__ == "__main__": ALL_START = time.time() print("Start counting time. ALL_START") # mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) if args.config_file.endswith("yaml"): cfg = setup_cfg(args) model = VisualizationDemo(cfg) elif args.config_file.endswith("py"): model = model_zoo.get(args.config_file, trained=True) model.cuda() model.eval() else: raise Exception(f"{args.config_file} is not supported.") if args.input: if len(args.input) == 1: args.input = glob.glob(osp.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" data_dir = osp.join(args.input[0], args.split) if args.video_src_names: # only process the given video sources video_src_names = args.video_src_names else: video_src_names = [
from torch.autograd import Variable import torch from torch import nn import numpy as np import onnx from onnx_tf.backend import prepare from detectron2 import model_zoo import torchvision.transforms as transforms # Load the trained model from file my_model = model_zoo.get("COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml", trained=False) #my_model = torch.load('/home/ubuntu/cs/publaynet/output/model_0021999.pth') if torch.cuda.is_available(): my_model.cuda() else: my_model.cpu() my_model.eval() ''' for key in my_model['model'].keys(): #print(my_model['model'].keys())# ['backbone.bottom_up.stem.conv1.weight'].size()) print(key) print(my_model['model'][key].size()) ''' # Export the trained model to ONNX input_list = [] toTensor = transforms.Compose([transforms.ToTensor()]) #dummy_input = Variable(torch.randn(1, 1, 1)) # nchw one black and white 28 x 28 picture will be the input to the model
def test_get_returns_model(self): model = model_zoo.get("Misc/scratch_mask_rcnn_R_50_FPN_3x_gn.yaml", trained=False) self.assertIsInstance(model, GeneralizedRCNN) self.assertIsInstance(model.backbone, FPN)
metadata = MetadataCatalog.get('debris_dataset_train') dataset_dicts = get_dataset(data_paths[0]) for d in random.sample(dataset_dicts, 10): img = cv2.imread(d['file_name']) visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, scale=0.3) out = visualizer.draw_dataset_dict(d) cv2.imshow('img{}'.format(d), out.get_image()[:, :, ::-1]) cv2.waitKey(0) cv2.destroyAllWindows() # Setup cfg parameters# # Use Faster-RCNN 101 layer model with ResNet backbone (R101-C4) cfg = get_cfg() model_zoo.get( 'COCO-Detection/faster_rcnn_R_50_C4_3x.yaml', True ) # True: Lets training initialize from model #faster_rcnn_R_101_C4_3x.yaml cfg.DATASETS.TRAIN = ('debris_dataset_train', ) cfg.DATASETS.TEST = ('debris_dataset_test', ) cfg.DATALOADER.NUM_WORKERS = 4 #cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url('COCO-Detection/faster_rcnn_R_101_C4_3x.yaml') cfg.SOLVER.IMS_PER_BATCH = 2 # CUDA out of memory if > 1 cfg.SOLVER.BASE_LR = 0.001 cfg.SOLVER.WARMUP_ITERS = 80000 #(1000) cfg.SOLVER.MAX_ITER = 100000 # maximum number of training iterations (1500) cfg.SOLVER.STEPS = (80000, 100000) # (1000, 1500) cfg.SOLVER.GAMMA = 0.05 cfg.SOLVER.CHECKPOINT_PERIOD = 25000 # make a checkpoint .weights file every 'x' iterations