def test_get_models_to_fuse(): model = create_model(max_operating_res=320) model = model.to('cpu') model.eval() replace_frozenbatchnorm_batchnorm(model) expected_layer_names = [[ 'backbone.body.conv1', 'backbone.body.bn1', 'backbone.body.relu' ], ['backbone.body.layer1.0'], ['backbone.body.layer1.1'], ['backbone.body.layer1.2'], ['backbone.body.layer2.0'], ['backbone.body.layer2.1'], ['backbone.body.layer2.2'], ['backbone.body.layer2.3'], ['backbone.body.layer3.0'], ['backbone.body.layer3.1'], ['backbone.body.layer3.2'], ['backbone.body.layer3.3'], ['backbone.body.layer3.4'], ['backbone.body.layer3.5'], ['backbone.body.layer4.0'], ['backbone.body.layer4.1'], ['backbone.body.layer4.2']] modules_to_fuse = get_modules_to_fuse(model) for i, j in zip(expected_layer_names, modules_to_fuse): for x, z in zip(i, j): assert x == z assert isinstance(_get_module(model, modules_to_fuse[0][0]), nn.Conv2d) assert isinstance(_get_module(model, modules_to_fuse[0][1]), nn.BatchNorm2d) assert isinstance(_get_module(model, modules_to_fuse[0][2]), nn.ReLU) for module_list in modules_to_fuse[1:]: assert isinstance(_get_module(model, module_list[0]), Bottleneck)
def compare_raw_vs_filtered(video_file): model = create_model() if not os.path.exists("df_raw.csv"): df_raw = get_raw_df_from_movie(video_file, model) df_raw.to_csv("df_raw.csv") else: df_raw = pd.read_csv("df_raw.csv") df_fil = get_tracked_df_from_df(df_raw) compare_multiple_dataframes(video_file, video_file.replace(':', '_').replace('\\', '_'), df_raw, df_fil)
def test_auu_data(): auu_data_root = r'D:\tms_data\aau-rainsnow\Hjorringvej\Hjorringvej-2' video_files = [ osp.join(r, f) for (r, _, fs) in os.walk(auu_data_root) for f in fs if 'avi' in f or 'mkv' in f ] model = create_model() for video_path in video_files: image_gen = framedatapoint_generator(video_path, skip=5) image_gen1, image_gen2 = tee(image_gen) for idx, fdp in enumerate( plot_detections(image_gen1, compute(image_gen2, model))): cv2.imshow("image", fdp.image) cv2.waitKey(1)
def test_replace_frozenbatchnorm_batchnorm(): test_image = osp.join(osp.dirname(__file__), 'data', 'test_image.PNG') test_image = cv2.cvtColor(cv2.imread(test_image), cv2.COLOR_BGR2RGB) input_images = [FrameDatapoint(test_image, 1)] model = create_model() model = model.eval().to('cpu') expected_predictions = list(compute(input_images, model, cdevice='cpu')) replace_frozenbatchnorm_batchnorm(model) for child in model.modules(): assert not isinstance(child, FrozenBatchNorm2d) model = model.eval().to('cpu') actual_predictions = list(compute(input_images, model, cdevice='cpu')) assert len(actual_predictions) == len(expected_predictions) assert (actual_predictions[0].pred['boxes'] == expected_predictions[0].pred['boxes']).all()
def test_TruckDetector_pred_iter_to_pandas(): auu_data_root = r'D:\aau-rainsnow\Hjorringvej\Hjorringvej-2' video_file = [ osp.join(r, f) for (r, _, fs) in os.walk(auu_data_root) for f in fs if 'avi' in f or 'mkv' in f ][0] #file 'Hjorringvej\\Hjorringvej-2\\cam1.mkv' has 6000 frames model = create_model(max_operating_res=320) image_gen = framedatapoint_generator(video_file, skip=6000 // 30) image_gen1, image_gen2 = tee(image_gen) pred_gen = compute(image_gen1, model) df = pred_iter_to_pandas(pred_gen) pred_gen_from_df = pandas_to_pred_iter(df) for idx, fdp in enumerate(plot_detections(image_gen2, pred_gen_from_df)): cv2.imshow("image", fdp.image) cv2.waitKey(1) if idx == 5: break
def test_fusing(): test_image = osp.join(osp.dirname(__file__), 'data', 'test_image.PNG') test_image = cv2.cvtColor(cv2.imread(test_image), cv2.COLOR_BGR2RGB) input_images = [FrameDatapoint(test_image, 1)] model = create_model() model = model.to('cpu') expected_predictions = list(compute(input_images, model, cdevice='cpu')) model = model.to('cpu') modules_to_fuse = get_modules_to_fuse(model) replace_frozenbatchnorm_batchnorm(model) model.eval() fuse_modules(model, modules_to_fuse, inplace=True, fuser_func=custom_fuse_func) model = model.to('cpu') actual_predictions = list(compute(input_images, model, cdevice='cpu')) assert len(expected_predictions) == len(actual_predictions) assert (expected_predictions[0].pred['boxes'] == actual_predictions[0].pred['boxes']).all() assert abs((expected_predictions[0].pred['scores'] - actual_predictions[0].pred['scores'])).sum() < 0.1
def test_quantiaztion(): with torch.no_grad(): test_image = osp.join(osp.dirname(__file__), 'data', 'test_image.PNG') test_image = cv2.cvtColor(cv2.imread(test_image), cv2.COLOR_BGR2RGB) input_images = [FrameDatapoint(test_image, 1)] * 5 model = create_model() model = model.to('cpu') unoptimized_model_size = size_of_model(model) num_evaluations = 1 model.backbone.fpn = QuantizedFeaturePyramidNetwork(model.backbone.fpn) start = time.time() for i in range(num_evaluations): expected_predictions = list( compute(input_images, model, cdevice='cpu')) end = time.time() unoptimized = (end - start) / num_evaluations model = create_model(conf_thr=0.1) model = model.to('cpu') modules_to_fuse = get_modules_to_fuse(model) replace_frozenbatchnorm_batchnorm(model) model.eval() fuse_modules(model, modules_to_fuse, inplace=True, fuser_func=custom_fuse_func) def run_fn(model, run_agrs): return compute(input_images, model) from torch.quantization.QConfig import default_qconfig from torch.quantization.default_mappings import DEFAULT_MODULE_MAPPING from torch.quantization.quantize import prepare, propagate_qconfig_ import torch.nn.intrinsic as nni import itertools for child in model.modules(): if isinstance(child, nn.ReLU): child.inplace = False # TODO i removed the linear layers because they were too complicated for quantization. too much logic qconfig_spec = dict( zip({nn.Conv2d, nni.ConvReLU2d, nn.ReLU}, itertools.repeat(default_qconfig))) propagate_qconfig_(model.backbone, qconfig_spec) model.eval() model = torch.quantization.quantize(model, run_fn=run_fn, run_args={}, mapping=DEFAULT_MODULE_MAPPING) # model = torch.quantization.quantize_dynamic( # model,qconfig_spec=, dtype=torch.qint8,mapping=DEFAULT_MODULE_MAPPING # ) print(model) model.transform = QuantizedGeneralizedRCNNTransform(model.transform) model.backbone.fpn = QuantizedFeaturePyramidNetwork(model.backbone.fpn) # model.rpn = QuantizedRegionProposalNetwork(model.rpn) optimized_model_size = size_of_model(model) model = model.to('cpu') model.eval() start = time.time() for i in range(num_evaluations): actual_predictions = list( compute(input_images, model, cdevice='cpu')) end = time.time() optimized = (end - start) / num_evaluations pprint(actual_predictions[0].pred['boxes']) pprint(expected_predictions[0].pred['boxes']) # assert optimized < unoptimized print("time UNOPTIMIZED VS OPTIMIZED", unoptimized, optimized) print("size UNOPTIMIZED VS OPTIMIZED", unoptimized_model_size, optimized_model_size)