def test_compare_model_outputs_lstm_dynamic_fx(self): r"""Compare the output of LSTM layer in dynamic quantized model and corresponding output of linear layer in float model """ qconfig_dict = {"object_type": [(nn.LSTM, default_dynamic_qconfig)]} float_model = LSTMwithHiddenDynamicModel() float_model.eval() prepared_model = prepare_fx(float_model, qconfig_dict) prepared_float_model = copy.deepcopy(prepared_model) q_model = convert_fx(prepared_model) lstm_input = torch.rand((1, 1, 2)) lstm_hidden = (torch.rand(1, 1, 2), torch.rand(1, 1, 2)) expected_act_compare_dict_keys = { "x.stats", "hid.stats", "lstm_1.stats" } self.compare_and_validate_model_outputs_results_fx( prepared_float_model, q_model, expected_act_compare_dict_keys, lstm_input, lstm_hidden, )
def test_compare_model_stub_lstm_dynamic(self): r"""Compare the output of dynamic quantized LSTM layer and its float shadow module""" qengine = torch.backends.quantized.engine def compare_and_validate_results(float_model, q_model, module_swap_list, input, hidden): ob_dict = compare_model_stub(float_model, q_model, module_swap_list, input, hidden) self.assertEqual(len(ob_dict), 1) for k, v in ob_dict.items(): self.assertTrue(len(v["float"]) == len(v["quantized"])) for i, val in enumerate(v["quantized"]): self.assertTrue( v["float"][i].shape == v["quantized"][i].shape) lstm_input = torch.rand((1, 1, 2)) lstm_hidden = (torch.rand(1, 1, 2), torch.rand(1, 1, 2)) model_list = [LSTMwithHiddenDynamicModel(qengine)] module_swap_list = [nn.Linear, nn.LSTM] for model in model_list: model.eval() if hasattr(model, "fuse_model"): model.fuse_model() q_model = quantize_dynamic(model) compare_and_validate_results(model, q_model, module_swap_list, lstm_input, lstm_hidden)
def test_compare_model_stub_lstm_dynamic_fx(self): r"""Compare the output of dynamic quantized linear layer and its float shadow module""" qconfig_dict = {"object_type": [(nn.LSTM, default_dynamic_qconfig)]} float_model = LSTMwithHiddenDynamicModel() float_model.eval() prepared_model = prepare_fx(float_model, qconfig_dict) prepared_float_model = copy.deepcopy(prepared_model) prepared_float_model.eval() q_model = convert_fx(prepared_model) module_swap_list = [nn.LSTM] lstm_input = torch.rand((1, 1, 2)) lstm_hidden = (torch.rand(1, 1, 2), torch.rand(1, 1, 2)) expected_ob_dict_keys = {"lstm.stats"} self.compare_and_validate_model_stub_results_fx( prepared_float_model, q_model, module_swap_list, expected_ob_dict_keys, lstm_input, lstm_hidden, )
def test_compare_model_outputs_lstm_dynamic(self): r"""Compare the output of LSTM layer in dynamic quantized model and corresponding output of conv layer in float model """ qengine = torch.backends.quantized.engine def compare_and_validate_results(float_model, q_model, input, hidden): act_compare_dict = compare_model_outputs(float_model, q_model, input, hidden) expected_act_compare_dict_keys = {"lstm.stats"} self.assertTrue( act_compare_dict.keys() == expected_act_compare_dict_keys) for k, v in act_compare_dict.items(): self.assertTrue(v["float"][0].shape == v["quantized"][0].shape) lstm_input = torch.rand((1, 1, 2)) lstm_hidden = (torch.rand(1, 1, 2), torch.rand(1, 1, 2)) model_list = [LSTMwithHiddenDynamicModel(qengine)] for model in model_list: model.eval() if hasattr(model, "fuse_model"): model.fuse_model() q_model = quantize_dynamic(model) compare_and_validate_results(model, q_model, lstm_input, lstm_hidden)
def test_compare_shadow_activations_lstm_dynamic(self): qconfig_dict = {"object_type": [(nn.LSTM, default_dynamic_qconfig)]} m = LSTMwithHiddenDynamicModel().eval() lstm_input = torch.rand((1, 1, 2)) lstm_hidden = (torch.rand(1, 1, 2), torch.rand(1, 1, 2)) # TODO(future PR): enable scripting (quant prepared LSTM not scriptable) res = self._test_match_shadow_activations( m, (lstm_input, lstm_hidden), results_len=1, qconfig_dict=qconfig_dict, skip_scripting=True)
def test_compare_weights_lstm_dynamic_fx(self): r"""Compare the weights of float and dynamic quantized lstm layer""" qconfig_dict = {"object_type": [(nn.LSTM, default_dynamic_qconfig)]} float_model = LSTMwithHiddenDynamicModel() float_model.eval() prepared_model = prepare_fx(float_model, qconfig_dict) prepared_float_model = copy.deepcopy(prepared_model) prepared_float_model.eval() q_model = convert_fx(prepared_model) expected_weight_dict_keys = {"lstm._all_weight_values.0.param"} self.compare_and_validate_model_weights_results_fx( prepared_float_model, q_model, expected_weight_dict_keys)
def test_compare_weights_lstm_dynamic(self): r"""Compare the weights of float and dynamic quantized LSTM layer """ qengine = torch.backends.quantized.engine def compare_and_validate_results(float_model, q_model): weight_dict = compare_weights(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) model_list = [LSTMwithHiddenDynamicModel(qengine)] for model in model_list: model.eval() if hasattr(model, "fuse_model"): model.fuse_model() q_model = quantize_dynamic(model) compare_and_validate_results(model, q_model)
def test_compare_weights_lstm_dynamic(self): qconfig_dict = {"object_type": [(nn.LSTM, default_dynamic_qconfig)]} m = LSTMwithHiddenDynamicModel().eval() res = self._test_extract_weights(m, results_len=1, qconfig_dict=qconfig_dict)