ai-edge-quantizer-nightly 0.0.1.dev20250302__py3-none-any.whl → 0.5.0.dev20260103__py3-none-any.whl

ai_edge_quantizer/recipe_manager.py

@@ -82,7 +82,6 @@ class RecipeManager:
         str, list[OpQuantizationRecipe]
     ] = collections.OrderedDict()
 
-  # TODO: b/335254997 - Check if an op quantization config is supported.
   def add_quantization_config(
       self,
       regex: str,
@@ -109,6 +108,11 @@ class RecipeManager:
         configuration will be used.
       algorithm_key: Algorithm key to be applied.
     """
+    try:
+      algorithm_manager.AlgorithmName(algorithm_key)
+    except ValueError as e:
+      raise ValueError(f'Unsupported algorithm key: {algorithm_key}.') from e
+
     if op_config is None:
       op_config = _OpQuantizationConfig()
 
@@ -243,3 +247,156 @@ class RecipeManager:
       ):
         return True
     return False
+
+  def add_dynamic_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      num_bits: int,
+      granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a dynamic quantization configuration to the recipe.
+
+    During dynamic quantization, activations are not processed by AEQ and
+    remain in float format. The runtime kernel is expected to quantize these
+    activations on-the-fly, as indicated by compute_precision=Integer and
+    explicit_dequantize=False.
+
+    The model quality may suffer due to the on-the-fly quantization. If quality
+    is a concern, consider using weight-only
+    quantization.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      num_bits: Number of bits for quantization.
+      granularity: Granularity of quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    weight_config = qtyping.TensorQuantizationConfig(
+        num_bits=num_bits,
+        symmetric=True,  # LiteRT kernels only support symmetric quantized
+        # weights.
+        granularity=granularity,
+    )
+    self.add_quantization_config(
+        regex,
+        operation_name,
+        op_config=_OpQuantizationConfig(
+            weight_tensor_config=weight_config,
+            compute_precision=qtyping.ComputePrecision.INTEGER,
+            explicit_dequantize=False,
+        ),
+        algorithm_key=algorithm_key,
+    )
+
+  def add_weight_only_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      num_bits: int,
+      granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a weight only quantization configuration to the recipe.
+
+    In weight-only quantization, weights are quantized, but the actual operation
+    (op) computation remains in float. The quantized weight is explicitly
+    dequantized before being fed into the op. This is achieved by inserting a
+    dequantize op between the quantized weight and the consuming op. To enable
+    this, both compute_precision will be set to Float and explicit_dequantize to
+    True.
+
+    Weight-only quantization is useful for reducing model size but may
+    not decrease latency due to float computation. However, quantized model
+    generally has better quality than other quantization options (e.g., dynamic
+    range quantization) due to no loss of precision on activations. If latency
+    is a concern, consider using dynamic quantization.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      num_bits: Number of bits for quantization.
+      granularity: Granularity of quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    # Default to integer quantization but allow float quantization for
+    # FLOAT_CASTING algorithm. This is to support weight-only quantization with
+    # fp16 weights.
+    weight_dtype = qtyping.TensorDataType.INT
+    if algorithm_key == AlgorithmName.FLOAT_CASTING:
+      weight_dtype = qtyping.TensorDataType.FLOAT
+
+    weight_config = qtyping.TensorQuantizationConfig(
+        num_bits=num_bits,
+        symmetric=True,  # TFL kernels only support symmetric quantized weights.
+        granularity=granularity,
+        dtype=weight_dtype,
+    )
+    self.add_quantization_config(
+        regex,
+        operation_name,
+        op_config=_OpQuantizationConfig(
+            weight_tensor_config=weight_config,
+            compute_precision=qtyping.ComputePrecision.FLOAT,
+            explicit_dequantize=True,
+        ),
+        algorithm_key=algorithm_key,
+    )
+
+  def add_static_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      activation_num_bits: int,
+      weight_num_bits: int,
+      weight_granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a static range quantization configuration to the recipe.
+
+    In static quantization, both weights and activations are quantized. This
+    requires a calibration step to determine the quantization parameters (e.g.,
+    min/max ranges) for activations. The quantized model uses integer arithmetic
+    for computations, which can lead to significant latency reductions.
+
+    However, calibration is needed to determine the quantization parameters for
+    activations, which requires sample data and may lead to quality loss. If
+    there is no hardware requirement for full integer quantization, consider
+    using dynamic quantization for simplicity.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      activation_num_bits: Number of bits for activation quantization.
+      weight_num_bits: Number of bits for weight quantization.
+      weight_granularity: Granularity of weight quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    if activation_num_bits not in [16, 8]:
+      raise ValueError(
+          'Activation quantization is only supported for 16 or 8 bits.'
+      )
+    # INT16 is symmetric and INT8 is asymmetric due to LiteRT kernel
+    # limitations.
+    activation_symmetric = activation_num_bits == 16
+    activation_config = qtyping.TensorQuantizationConfig(
+        num_bits=activation_num_bits, symmetric=activation_symmetric
+    )
+    weight_config = qtyping.TensorQuantizationConfig(
+        num_bits=weight_num_bits,
+        symmetric=True,  # TFL kernels only support symmetric quantized weights.
+        granularity=weight_granularity,
+    )
+    self.add_quantization_config(
+        regex,
+        operation_name,
+        op_config=_OpQuantizationConfig(
+            activation_tensor_config=activation_config,
+            weight_tensor_config=weight_config,
+            compute_precision=qtyping.ComputePrecision.INTEGER,
+            explicit_dequantize=False,
+        ),
+        algorithm_key=algorithm_key,
+    )

ai_edge_quantizer/recipe_manager_test.py

@@ -29,19 +29,6 @@ _AlgorithmName = recipe_manager.AlgorithmName
 _QuantGranularity = qtyping.QuantGranularity
 
 
-# Sample functions for test cases.
-def _sample_init_qsvs(*_, **__):
-  return 1.0, dict()
-
-
-def _sample_calibration_func(*_, **__):
-  return 2.0, dict()
-
-
-def _sample_materialize_func(*_, **__):
-  return 3.0, dict()
-
-
 def _sample_check_op_config_func(op_name, op_config, _):
   if (
       op_config.weight_tensor_config is not None
@@ -67,6 +54,16 @@ def _add_default_int8xint8_integer_recipe(recipe_manager_object):
 
 # register some currently unsupported ops for testing purposes
 def _register_testing_op(algorithm_key, tfl_op):
+  # Sample functions for test cases.
+  def _sample_init_qsvs(*_, **__):
+    return {'name': dict()}
+
+  def _sample_calibration_func(*_, **__):
+    return {'name2': dict()}
+
+  def _sample_materialize_func(*_, **__):
+    return []
+
   algorithm_manager.register_op_quant_config_validation_func(
       algorithm_key, _sample_check_op_config_func
   )
@@ -244,19 +241,6 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
               compute_precision=_ComputePrecision.INTEGER,  # DRQ.
           ),
       )
-    # Add unregistered algorithm
-    with self.assertRaisesWithPredicateMatch(
-        ValueError, lambda err: error_message in str(err)
-    ):
-      self._recipe_manager.add_quantization_config(
-          regex='.*/Dense/.*',
-          operation_name=_TFLOpName.FULLY_CONNECTED,
-          algorithm_key='AWQ',
-          op_config=qtyping.OpQuantizationConfig(
-              weight_tensor_config=_TensorQuantConfig(num_bits=8),
-              compute_precision=_ComputePrecision.INTEGER,  # DRQ.
-          ),
-      )
 
   def test_add_unsupported_num_bits_raise_error(self):
     test_op_name = _TFLOpName.FULLY_CONNECTED
@@ -296,6 +280,142 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
     # DRQ check.
     self.assertEqual(op_config.compute_precision, _ComputePrecision.INTEGER)
 
+  def test_add_unsupported_algorithm_key_raise_error(self):
+    error_message = 'Unsupported algorithm key'
+    with self.assertRaisesWithPredicateMatch(
+        ValueError, lambda err: error_message in str(err)
+    ):
+      self._recipe_manager.add_quantization_config(
+          regex='.*/Dense/.*',
+          operation_name=_TFLOpName.FULLY_CONNECTED,
+          algorithm_key='decomposed_hadamard',
+          op_config=qtyping.OpQuantizationConfig(
+              weight_tensor_config=_TensorQuantConfig(num_bits=8),
+          ),
+      )
+    with self.assertRaisesWithPredicateMatch(
+        ValueError, lambda err: error_message in str(err)
+    ):
+      self._recipe_manager.add_quantization_config(
+          regex='.*/Dense/.*',
+          operation_name=_TFLOpName.ALL_SUPPORTED,
+          algorithm_key='decomposed_hadamard',
+          op_config=qtyping.OpQuantizationConfig(
+              weight_tensor_config=_TensorQuantConfig(num_bits=8),
+          ),
+      )
+
+  def test_add_dynamic_config(self):
+    self._recipe_manager.add_dynamic_config(
+        regex='.*/Dense/.*',
+        operation_name=_TFLOpName.FULLY_CONNECTED,
+        num_bits=8,
+    )
+    alg_key, op_config = self._recipe_manager.get_quantization_configs(
+        _TFLOpName.FULLY_CONNECTED, 'model/Dense/op'
+    )
+    self.assertEqual(alg_key, _AlgorithmName.MIN_MAX_UNIFORM_QUANT)
+    self.assertEqual(op_config.compute_precision, _ComputePrecision.INTEGER)
+    self.assertFalse(op_config.explicit_dequantize)
+    self.assertIsNone(op_config.activation_tensor_config)
+    weight_tensor_config = op_config.weight_tensor_config
+    self.assertIsNotNone(weight_tensor_config)
+    self.assertEqual(weight_tensor_config.num_bits, 8)
+    self.assertTrue(weight_tensor_config.symmetric)
+    self.assertEqual(
+        weight_tensor_config.granularity,
+        _QuantGranularity.CHANNELWISE,
+    )
+
+  @parameterized.parameters(4, 8)
+  def test_add_weight_only_config_int(self, num_bits):
+    self._recipe_manager.add_weight_only_config(
+        regex='.*/Dense/.*',
+        operation_name=_TFLOpName.FULLY_CONNECTED,
+        num_bits=num_bits,
+    )
+    alg_key, op_config = self._recipe_manager.get_quantization_configs(
+        _TFLOpName.FULLY_CONNECTED, 'model/Dense/op'
+    )
+    self.assertEqual(alg_key, _AlgorithmName.MIN_MAX_UNIFORM_QUANT)
+    self.assertEqual(op_config.compute_precision, _ComputePrecision.FLOAT)
+    self.assertTrue(op_config.explicit_dequantize)
+    self.assertIsNone(op_config.activation_tensor_config)
+    weight_tensor_config = op_config.weight_tensor_config
+    self.assertIsNotNone(weight_tensor_config)
+    self.assertEqual(weight_tensor_config.num_bits, num_bits)
+    self.assertTrue(weight_tensor_config.symmetric)
+    self.assertEqual(
+        weight_tensor_config.granularity,
+        _QuantGranularity.CHANNELWISE,
+    )
+    self.assertEqual(weight_tensor_config.dtype, _TensorDataType.INT)
+
+  def test_add_weight_only_config_fp16(self):
+    self._recipe_manager.add_weight_only_config(
+        regex='.*/Dense2/.*',
+        operation_name=_TFLOpName.FULLY_CONNECTED,
+        num_bits=16,
+        algorithm_key=_AlgorithmName.FLOAT_CASTING,
+    )
+    alg_key, op_config = self._recipe_manager.get_quantization_configs(
+        _TFLOpName.FULLY_CONNECTED, 'model/Dense2/op'
+    )
+    self.assertEqual(alg_key, _AlgorithmName.FLOAT_CASTING)
+    self.assertEqual(op_config.compute_precision, _ComputePrecision.FLOAT)
+    self.assertTrue(op_config.explicit_dequantize)
+    self.assertIsNone(op_config.activation_tensor_config)
+    weight_tensor_config = op_config.weight_tensor_config
+    self.assertIsNotNone(weight_tensor_config)
+    self.assertEqual(weight_tensor_config.num_bits, 16)
+    self.assertTrue(weight_tensor_config.symmetric)
+    self.assertEqual(
+        weight_tensor_config.granularity,
+        _QuantGranularity.CHANNELWISE,
+    )
+    self.assertEqual(weight_tensor_config.dtype, _TensorDataType.FLOAT)
+
+  def test_add_weight_only_config_fp8_raise_error(self):
+    error_message = (
+        'float casting quantization config requires number of bits to be set'
+        ' as 16'
+    )
+    with self.assertRaisesWithPredicateMatch(
+        ValueError, lambda err: error_message in str(err)
+    ):
+      self._recipe_manager.add_weight_only_config(
+          regex='.*/Dense2/.*',
+          operation_name=_TFLOpName.FULLY_CONNECTED,
+          num_bits=8,
+          algorithm_key=_AlgorithmName.FLOAT_CASTING,
+      )
+
+  def test_add_static_config(self):
+    self._recipe_manager.add_static_config(
+        regex='.*/Dense/.*',
+        operation_name=_TFLOpName.FULLY_CONNECTED,
+        activation_num_bits=8,
+        weight_num_bits=4,
+    )
+    alg_key, op_config = self._recipe_manager.get_quantization_configs(
+        _TFLOpName.FULLY_CONNECTED, 'model/Dense/op'
+    )
+    self.assertEqual(alg_key, _AlgorithmName.MIN_MAX_UNIFORM_QUANT)
+    self.assertEqual(op_config.compute_precision, _ComputePrecision.INTEGER)
+    self.assertFalse(op_config.explicit_dequantize)
+    activation_tensor_config = op_config.activation_tensor_config
+    self.assertIsNotNone(activation_tensor_config)
+    self.assertEqual(activation_tensor_config.num_bits, 8)
+    self.assertFalse(activation_tensor_config.symmetric)
+    weight_tensor_config = op_config.weight_tensor_config
+    self.assertIsNotNone(weight_tensor_config)
+    self.assertEqual(weight_tensor_config.num_bits, 4)
+    self.assertTrue(weight_tensor_config.symmetric)
+    self.assertEqual(
+        weight_tensor_config.granularity,
+        _QuantGranularity.CHANNELWISE,
+    )
+
   def test_set_full_integer_quantization_config(self):
     _add_default_int8xint8_integer_recipe(self._recipe_manager)
     # Full integer setting is global
@@ -461,14 +581,12 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
                     'symmetric': False,
                     'granularity': _QuantGranularity.TENSORWISE,
                     'dtype': 'INT',
-                    'block_size': 0,
                 },
                 'weight_tensor_config': {
                     'num_bits': 8,
                     'symmetric': True,
                     'granularity': _QuantGranularity.TENSORWISE,
                     'dtype': 'INT',
-                    'block_size': 0,
                 },
                 # WEIGHT_ONLY.
                 'compute_precision': _ComputePrecision.INTEGER,
@@ -487,7 +605,6 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
                     'num_bits': 8,
                     'symmetric': True,
                     'granularity': _QuantGranularity.TENSORWISE,
-                    'block_size': 0,
                 },
                 # WEIGHT_ONLY.
                 'compute_precision': _ComputePrecision.FLOAT,
@@ -506,7 +623,6 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
                     'num_bits': 4,
                     'symmetric': True,
                     'granularity': _QuantGranularity.TENSORWISE,
-                    'block_size': 0,
                 },
                 # WEIGHT_ONLY.
                 'compute_precision': _ComputePrecision.FLOAT,
@@ -525,7 +641,6 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
                     'num_bits': 6,
                     'symmetric': True,
                     'granularity': _QuantGranularity.TENSORWISE,
-                    'block_size': 0,
                 },
                 # WEIGHT_ONLY.
                 'compute_precision': _ComputePrecision.FLOAT,
@@ -544,7 +659,6 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
                     'num_bits': 3,
                     'symmetric': True,
                     'granularity': _QuantGranularity.TENSORWISE,
-                    'block_size': 0,
                 },
                 # WEIGHT_ONLY.
                 'compute_precision': _ComputePrecision.FLOAT,

ai_edge_quantizer/recipe_test.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 
 import os
+import unittest  # pylint: disable=unused-import, required for OSS.
 
 from absl.testing import parameterized
 
@@ -21,6 +22,7 @@ from tensorflow.python.platform import googletest
 from ai_edge_quantizer import quantizer
 from ai_edge_quantizer import recipe
 from ai_edge_quantizer.utils import test_utils
+from ai_edge_quantizer.utils import tfl_interpreter_utils
 
 
 _TEST_DATA_PREFIX_PATH = test_utils.get_path_to_datafile('')
@@ -30,21 +32,67 @@ class RecipeTest(parameterized.TestCase):
 
   def setUp(self):
     super().setUp()
-    self._test_model_path = os.path.join(
+    # Weights has < 1024 elements so legacy recipe will not quantize it.
+    self._small_model_path = os.path.join(
         _TEST_DATA_PREFIX_PATH,
         'tests/models/single_conv2d_transpose_bias.tflite',
     )
+    self._test_model_path = os.path.join(
+        _TEST_DATA_PREFIX_PATH,
+        'tests/models/conv_fc_mnist.tflite',
+    )
 
-  def _quantize_with_recipe_func(self, recipe_func):
-    qt = quantizer.Quantizer(self._test_model_path)
+  def _quantize_with_recipe_func(self, recipe_func, test_model_path):
+    qt = quantizer.Quantizer(test_model_path)
     qt.load_quantization_recipe(recipe_func())
     self.assertIsNone(qt._result.quantized_model)
-    quant_result = qt.quantize()
-    self.assertIsNotNone(quant_result.quantized_model)
-    return quant_result
-
+    if qt.need_calibration:
+      calibration_data = tfl_interpreter_utils.create_random_normal_input_data(
+          qt.float_model,
+          num_samples=1,
+      )
+      calibration_result = qt.calibrate(calibration_data)
+      quantization_result = qt.quantize(calibration_result)
+    else:
+      quantization_result = qt.quantize()
+    self.assertIsNotNone(quantization_result.quantized_model)
+    return quantization_result
+
+  @unittest.skip('skipping due to b/438971945')
   def test_quantization_from_dynamic_wi8_afp32_func_succeeds(self):
-    quant_result = self._quantize_with_recipe_func(recipe.dynamic_wi8_afp32)
+    quant_result = self._quantize_with_recipe_func(
+        recipe.dynamic_wi8_afp32, self._test_model_path
+    )
+    self.assertLess(
+        len(quant_result.quantized_model),
+        os.path.getsize(self._test_model_path),
+    )
+
+  @unittest.skip('skipping due to b/438971945')
+  def test_quantization_from_dynamic_wi4_afp32_func_succeeds(self):
+    quant_result = self._quantize_with_recipe_func(
+        recipe.dynamic_wi4_afp32, self._test_model_path
+    )
+    self.assertLess(
+        len(quant_result.quantized_model),
+        os.path.getsize(self._test_model_path),
+    )
+
+  @unittest.skip('skipping due to b/438971945')
+  def test_quantization_from_weight_only_wi8_afp32_func_succeeds(self):
+    quant_result = self._quantize_with_recipe_func(
+        recipe.weight_only_wi8_afp32, self._test_model_path
+    )
+    self.assertLess(
+        len(quant_result.quantized_model),
+        os.path.getsize(self._test_model_path),
+    )
+
+  @unittest.skip('skipping due to b/438971945')
+  def test_quantization_from_weight_only_wi4_afp32_func_succeeds(self):
+    quant_result = self._quantize_with_recipe_func(
+        recipe.weight_only_wi4_afp32, self._test_model_path
+    )
     self.assertLess(
         len(quant_result.quantized_model),
         os.path.getsize(self._test_model_path),
@@ -52,11 +100,12 @@ class RecipeTest(parameterized.TestCase):
 
   def test_quantization_from_dynamic_legacy_wi8_afp32_func_succeeds(self):
     quant_result = self._quantize_with_recipe_func(
-        recipe.dynamic_legacy_wi8_afp32
+        recipe.dynamic_legacy_wi8_afp32,
+        self._small_model_path,
     )
     self.assertLen(
         quant_result.quantized_model,
-        os.path.getsize(self._test_model_path),
+        os.path.getsize(self._small_model_path),
     )
 
   @parameterized.named_parameters(
@@ -65,28 +114,55 @@ class RecipeTest(parameterized.TestCase):
           recipe_json_path='recipes/dynamic_wi8_afp32_recipe.json',
           recipe_func=recipe.dynamic_wi8_afp32,
       ),
+      dict(
+          testcase_name='weight_only_wi8_afp32',
+          recipe_json_path='recipes/default_af32w8float_recipe.json',
+          recipe_func=recipe.weight_only_wi8_afp32,
+      ),
+      dict(
+          testcase_name='weight_only_wi4_afp32',
+          recipe_json_path='recipes/default_af32w4float_recipe.json',
+          recipe_func=recipe.weight_only_wi4_afp32,
+      ),
       dict(
           testcase_name='dynamic_legacy_wi8_afp32',
           recipe_json_path='recipes/dynamic_legacy_wi8_afp32_recipe.json',
           recipe_func=recipe.dynamic_legacy_wi8_afp32,
       ),
+      dict(
+          testcase_name='a8w8',
+          recipe_json_path='recipes/default_a8w8_recipe.json',
+          recipe_func=recipe.static_wi8_ai8,
+      ),
+      dict(
+          testcase_name='a16w8',
+          recipe_json_path='recipes/default_a16w8_recipe.json',
+          recipe_func=recipe.static_wi8_ai16,
+      ),
   )
+  @unittest.skip('skipping due to b/438971945')
   def test_recipe_func_and_json_matches(self, recipe_json_path, recipe_func):
     # Quantize with recipe from function in recipe module.
-    quant_result_from_func = self._quantize_with_recipe_func(recipe_func)
+    quant_result_from_func = self._quantize_with_recipe_func(
+        recipe_func, self._test_model_path
+    )
 
     # Quantize with recipe from json file.
     qt_json = quantizer.Quantizer(self._test_model_path)
     json_recipe_path = os.path.join(_TEST_DATA_PREFIX_PATH, recipe_json_path)
     qt_json.load_quantization_recipe(json_recipe_path)
-    quant_result_from_json = qt_json.quantize()
+    if qt_json.need_calibration:
+      calibration_data = tfl_interpreter_utils.create_random_normal_input_data(
+          qt_json.float_model,
+          num_samples=1,
+      )
+      calibration_result = qt_json.calibrate(calibration_data)
+      quant_result_from_json = qt_json.quantize(calibration_result)
+    else:
+      quant_result_from_json = qt_json.quantize()
     self.assertIsNotNone(quant_result_from_json.quantized_model)
 
-    # Check if the recipes and quantized models match.
-    self.assertEqual(
-        quant_result_from_func.recipe,
-        quant_result_from_json.recipe,
-    )
+    # Check if the quantized models match.
     self.assertEqual(
         len(quant_result_from_func.quantized_model),
         len(quant_result_from_json.quantized_model),