def setup(tmp_dir):
ds_name = create_local_dataset(tmp_dir, 5, 10, 10)
runner = default_runner.Detectron2GoRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
cfg.merge_from_list(
(["MODEL.META_ARCHITECTURE", "MetaArchForTestQAT"] +
["QUANTIZATION.QAT.ENABLED", "True"] +
["QUANTIZATION.QAT.START_ITER", "0"] +
["QUANTIZATION.QAT.ENABLE_OBSERVER_ITER", "0"]))
return runner, cfg
def test_d2go_runner_test(self):
with tempfile.TemporaryDirectory() as tmp_dir:
ds_name = create_local_dataset(tmp_dir, 5, 10, 10)
runner = default_runner.Detectron2GoRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
model = runner.build_model(cfg)
results = runner.do_test(cfg, model)
self.assertEqual(results["default"][ds_name]["bbox"]["AP"], 10.0)
default_runner._close_all_tbx_writers()
def test_d2go_runner_train(self):
with tempfile.TemporaryDirectory() as tmp_dir:
ds_name = create_local_dataset(tmp_dir, 5, 10, 10)
runner = default_runner.Detectron2GoRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
model = runner.build_model(cfg)
runner.do_train(cfg, model, resume=True)
final_model_path = os.path.join(tmp_dir, "model_final.pth")
self.assertTrue(os.path.isfile(final_model_path))
default_runner._close_all_tbx_writers()
def test_build_model(self):
with tempfile.TemporaryDirectory() as tmp_dir:
ds_name = create_local_dataset(tmp_dir, 5, 10, 10)
runner = oss_runner.DETRRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
model = runner.build_model(cfg)
dl = runner.build_detection_train_loader(cfg)
batch = next(iter(dl))
output = model(batch)
self.assertIsInstance(output, dict)
model.eval()
output = model(batch)
self.assertIsInstance(output, list)
default_runner._close_all_tbx_writers()
def setup(tmp_dir, backend, qat_method):
ds_name = create_local_dataset(tmp_dir, 5, 10, 10)
runner = default_runner.Detectron2GoRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
cfg.merge_from_list(
(["MODEL.META_ARCHITECTURE", "MetaArchForTestQAT1"] +
["QUANTIZATION.QAT.ENABLED", "True"] +
["QUANTIZATION.QAT.START_ITER", "1"] +
["QUANTIZATION.QAT.ENABLE_OBSERVER_ITER", "0"] +
["QUANTIZATION.QAT.ENABLE_LEARNABLE_OBSERVER_ITER", "2"] +
["QUANTIZATION.QAT.DISABLE_OBSERVER_ITER", "4"] +
["QUANTIZATION.QAT.FREEZE_BN_ITER", "4"] +
["QUANTIZATION.BACKEND", backend] +
["QUANTIZATION.QAT.FAKE_QUANT_METHOD", qat_method]))
return runner, cfg
def test_d2go_runner_ema(self):
with tempfile.TemporaryDirectory() as tmp_dir:
ds_name = create_local_dataset(tmp_dir, 5, 10, 10)
runner = default_runner.Detectron2GoRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
cfg.MODEL.META_ARCHITECTURE = "MetaArchForTestSingleValue"
cfg.MODEL_EMA.ENABLED = True
cfg.MODEL_EMA.DECAY = 0.9
def _run_train(cfg):
cfg = copy.deepcopy(cfg)
model = runner.build_model(cfg)
model = DistributedDataParallel(model, broadcast_buffers=False)
runner.do_train(cfg, model, True)
final_model_path = os.path.join(tmp_dir, "model_final.pth")
trained_weights = torch.load(final_model_path)
self.assertIn("ema_state", trained_weights)
default_runner._close_all_tbx_writers()
return final_model_path, model.module.ema_state
def _run_test(cfg, final_path, gt_ema):
cfg = copy.deepcopy(cfg)
cfg.MODEL.WEIGHTS = final_path
model = runner.build_model(cfg, eval_only=True)
self.assertGreater(len(model.ema_state.state), 0)
self.assertEqual(len(model.ema_state.state), len(gt_ema.state))
self.assertTrue(
_compare_state_dict(model.ema_state.state_dict(),
gt_ema.state_dict()))
results = runner.do_test(cfg, model)
self.assertEqual(results["default"][ds_name]["bbox"]["AP"],
3.0)
self.assertEqual(results["ema"][ds_name]["bbox"]["AP"], 9.0)
default_runner._close_all_tbx_writers()
def _run_build_model_with_ema_weight(cfg, final_path, gt_ema):
cfg = copy.deepcopy(cfg)
cfg.MODEL.WEIGHTS = final_path
cfg.MODEL_EMA.USE_EMA_WEIGHTS_FOR_EVAL_ONLY = True
model = runner.build_model(cfg, eval_only=True)
self.assertTrue(
_compare_state_dict(model.state_dict(),
gt_ema.state_dict()))
final_model_path, gt_ema = _run_train(cfg)
_run_test(cfg, final_model_path, gt_ema)
_run_build_model_with_ema_weight(cfg, final_model_path, gt_ema)
def test_d2go_build_evaluator(self):
for rotated, evaluator in [
(True, RotatedCOCOEvaluator),
(False, COCOEvaluator),
]:
with tempfile.TemporaryDirectory() as tmp_dir:
ds_name = create_local_dataset(tmp_dir,
5,
10,
10,
is_rotated=rotated)
runner = default_runner.Detectron2GoRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
ds_evaluators = runner.get_evaluator(cfg, ds_name, tmp_dir)
self.assertTrue(
isinstance(ds_evaluators._evaluators[0], evaluator))
def test_d2go_runner_trainer_hooks(self):
counts = 0
@TRAINER_HOOKS_REGISTRY.register()
def _check_hook_func(hooks):
nonlocal counts
counts = len(hooks)
print(hooks)
with tempfile.TemporaryDirectory() as tmp_dir:
ds_name = create_local_dataset(tmp_dir, 5, 10, 10)
runner = default_runner.Detectron2GoRunner()
cfg = _get_cfg(runner, tmp_dir, ds_name)
model = runner.build_model(cfg)
runner.do_train(cfg, model, resume=True)
default_runner._close_all_tbx_writers()
self.assertGreater(counts, 0)
def create_detection_cfg(runner, output_dir):
ds_name = create_local_dataset(output_dir, 5, 10, 10)
cfg = runner.get_default_cfg()
return get_det_meta_arch_cfg(cfg, ds_name, output_dir)
def maskrcnn_export_caffe2_vs_torchvision_opset_format_example(self):
with make_temp_directory("export_demo") as tmp_dir:
# use a fake dataset for ci
dataset_name = create_local_dataset(tmp_dir, 5, 224, 224)
config_list = [
"DATASETS.TRAIN",
(dataset_name, ),
"DATASETS.TEST",
(dataset_name, ),
]
# START_WIKI_EXAMPLE_TAG
runner = GeneralizedRCNNRunner()
cfg = runner.get_default_cfg()
cfg.merge_from_file("detectron2go://mask_rcnn_fbnetv3a_dsmask_C4.yaml")
cfg.merge_from_list(get_quick_test_config_opts())
cfg.merge_from_list(config_list)
# equivalent to running:
# exporter.par --runner GeneralizedRCNNRunner --config-file config.yaml --predictor-types torchscript tourchscript@c2_ops --output-dir tmp_dir
_ = main(
cfg,
tmp_dir,
runner,
predictor_types=["torchscript@c2_ops", "torchscript"],
)
# the path can be fetched from the return of main, here just use hard-coded values
torchvision_ops_model = torch.jit.load(
os.path.join(tmp_dir, "torchscript", "model.jit"))
caffe2_ops_model = torch.jit.load(
os.path.join(tmp_dir, "torchscript@c2_ops", "model.jit"))
# Running inference using torchvision-style format
image = torch.zeros(1, 64, 96) # chw 3D tensor
# The exported model can run on both cpu/gpu
device = "cuda:0" if torch.cuda.is_available() else "cpu"
torchvision_ops_model = torchvision_ops_model.to(device)
torchvision_style_outputs = torchvision_ops_model(
image) # suppose N instances are detected
# NOTE: the output are flattened tensors of the real output (which is a dict), they're
# ordered by the key in dict, which is deterministic for the given model, but it might
# be difficult to figure out just from model.jit file. The predictor_info.json from
# the same directory contains the `outputs_schema`, which indicate how the final output
# is constructed from flattened tensors.
(
pred_boxes, # torch.Size([N, 4])
pred_classes, # torch.Size([N])
pred_masks, # torch.Size([N, 1, Hmask, Wmask])
scores, # torch.Size([N])
image_sizes, # torch.Size([2])
) = torchvision_style_outputs
self.assertTrue(
all(x.device == torch.device(device)
for x in torchvision_style_outputs[:4]),
torchvision_style_outputs,
)
torch.testing.assert_close(image_sizes, torch.tensor([64, 96]))
# Running inference using caffe2-style format
data = torch.zeros(1, 1, 64, 96)
im_info = torch.tensor([[64, 96, 1.0]])
caffe2_style_outputs = caffe2_ops_model([data, im_info])
# NOTE: the output order is determined in the order of creating the tensor during
# forward function, it's also follow the order of original Caffe2 model.
roi_bbox_nms = caffe2_style_outputs[0] # torch.Size([N, 4])
roi_score_nms = caffe2_style_outputs[1] # torch.Size([N])
roi_class_nms = caffe2_style_outputs[2] # torch.Size([N])
mask_fcn_probs = caffe2_style_outputs[
3] # torch.Size([N, Cmask, Hmask, Wmask])
# relations between torchvision-style outputs and caffe2-style outputs
torch.testing.assert_close(pred_boxes,
roi_bbox_nms,
check_device=False)
torch.testing.assert_close(pred_classes,
roi_class_nms.to(torch.int64),
check_device=False)
torch.testing.assert_close(
pred_masks,
mask_fcn_probs[:, roi_class_nms.to(torch.int64), :, :],
check_device=False,
)
torch.testing.assert_close(scores, roi_score_nms, check_device=False)
