def test_compare_model_outputs_conv_static_fx(self):
r"""Compare the output of conv layer in static quantized model and corresponding
output of conv layer in float model
"""
qengine = torch.backends.quantized.engine
qconfig = get_default_qconfig(qengine)
qconfig_dict = {"": qconfig}
model_list = [ConvModel(), ConvBnReLUModel()]
for float_model in model_list:
float_model.eval()
prepared_model = prepare_fx(float_model, qconfig_dict)
prepared_float_model = copy.deepcopy(prepared_model)
# Run calibration
test_only_eval_fn(prepared_model, self.img_data_2d)
q_model = convert_fx(prepared_model)
expected_act_compare_dict_keys = {"x.stats", "conv.stats"}
self.compare_and_validate_model_outputs_results_fx(
prepared_float_model,
q_model,
expected_act_compare_dict_keys,
self.img_data_2d[0][0],
)
def test_compare_model_stub_conv_static_fx(self):
r"""Compare the output of static quantized conv layer and its float shadow module"""
qengine = torch.backends.quantized.engine
qconfig = get_default_qconfig(qengine)
qconfig_dict = {"": qconfig}
model_list = [ConvModel(), ConvBnReLUModel()]
for float_model in model_list:
float_model.eval()
prepared_model = prepare_fx(float_model, qconfig_dict)
prepared_float_model = copy.deepcopy(prepared_model)
# Run calibration
test_only_eval_fn(prepared_model, self.img_data_2d)
q_model = convert_fx(prepared_model)
module_swap_list = [nn.Conv2d, nni.modules.fused.ConvReLU2d]
expected_ob_dict_keys = {"conv.stats"}
self.compare_and_validate_model_stub_results_fx(
prepared_float_model,
q_model,
module_swap_list,
expected_ob_dict_keys,
self.img_data_2d[0][0],
)
def test_simple_conv(self):
torch.backends.quantized.engine = "onednn"
q_config_mapping = QConfigMapping()
q_config_mapping.set_global(torch.ao.quantization.get_default_qconfig(torch.backends.quantized.engine))
input = torch.randn(1, 3, 10, 10)
prepared_model = self._prepare_model_and_run_input(ConvModel(), q_config_mapping, input)
# run the detector
optims_str, per_channel_info = _detect_per_channel(prepared_model)
# no optims possible and there should be nothing in per_channel_status
self.assertEqual(
optims_str,
DEFAULT_NO_OPTIMS_ANSWER_STRING.format(torch.backends.quantized.engine),
)
self.assertEqual(per_channel_info["backend"], torch.backends.quantized.engine)
self.assertEqual(len(per_channel_info["per_channel_status"]), 1)
self.assertEqual(list(per_channel_info["per_channel_status"])[0], "conv")
self.assertEqual(
per_channel_info["per_channel_status"]["conv"]["per_channel_supported"],
True,
)
self.assertEqual(per_channel_info["per_channel_status"]["conv"]["per_channel_used"], True)
def test_compare_weights_conv_static_fx(self):
r"""Compare the weights of float and static quantized conv layer"""
def calibrate(model, calib_data):
model.eval()
with torch.no_grad():
for inp in calib_data:
model(*inp)
def compare_and_validate_results(float_model, q_model):
weight_dict = compare_weights_fx(float_model.state_dict(),
q_model.state_dict())
self.assertEqual(len(weight_dict), 1)
for k, v in weight_dict.items():
self.assertTrue(v["float"].shape == v["quantized"].shape)
qengine = torch.backends.quantized.engine
qconfig = get_default_qconfig(qengine)
qconfig_dict = {"": qconfig}
model_list = [ConvModel(), ConvBnModel(), ConvBNReLU()]
for float_model in model_list:
float_model.eval()
fused = fuse_fx(float_model)
prepared_model = prepare_fx(float_model, qconfig_dict)
# Run calibration
calibrate(prepared_model, self.img_data_2d)
q_model = convert_fx(prepared_model)
compare_and_validate_results(fused, q_model)
def test_compare_weights_conv(self):
test_cases = (
(ConvModel(), ),
(ConvBnModel(), ),
(ConvBnReLUModel(), ),
)
for m, in test_cases:
m.eval()
self._test_extract_weights(m, results_len=1)
def test_compare_shadow_activations_conv(self):
test_cases = (
(ConvModel(), ),
(ConvBnModel(), ),
(ConvBnReLUModel(), ),
)
for m, in test_cases:
m.eval()
res = self._test_match_shadow_activations(
m, (torch.randn(1, 3, 4, 4), ), results_len=1)
def test_compare_weights_conv_static_fx(self):
r"""Compare the weights of float and static quantized conv layer"""
qengine = torch.backends.quantized.engine
qconfig = get_default_qconfig(qengine)
qconfig_dict = {"": qconfig}
model_list = [ConvModel(), ConvBnModel(), ConvBnReLUModel()]
for float_model in model_list:
float_model.eval()
fused = fuse_fx(float_model)
prepared_model = prepare_fx(float_model, qconfig_dict)
# Run calibration
test_only_eval_fn(prepared_model, self.img_data_2d)
q_model = convert_fx(prepared_model)
expected_weight_dict_keys = {"conv.weight"}
self.compare_and_validate_model_weights_results_fx(
fused, q_model, expected_weight_dict_keys)
