ai-edge-quantizer-nightly 0.1.0.dev20250411__py3-none-any.whl → 0.1.0.dev20250413__py3-none-any.whl

ai_edge_quantizer/algorithm_manager_api_test.py

@@ -18,6 +18,7 @@
 from absl.testing import parameterized
 from tensorflow.python.platform import googletest
 from ai_edge_quantizer import algorithm_manager_api
+from ai_edge_quantizer import default_policy
 from ai_edge_quantizer import qtyping
 
 _TFLOpName = qtyping.TFLOperationName
@@ -205,6 +206,12 @@ class AlgorithmManagerApiTest(parameterized.TestCase):
         self._alg_manager._config_check_policy_registry[test_algorithm_name]
     )
 
+  def test_default_policy_not_empty(self):
+    """Tests that the default policy is not empty & no empty policy is generated."""
+    self.assertNotEmpty(default_policy.DEFAULT_CONFIG_CHECK_POLICY)
+    for policy in default_policy.DEFAULT_CONFIG_CHECK_POLICY.values():
+      self.assertNotEmpty(policy)
+
 
 if __name__ == "__main__":
   googletest.main()

ai_edge_quantizer/default_policy.py

@@ -57,6 +57,17 @@ DEFAULT_JSON_POLICY = """
       "explicit_dequantize": false,
       "compute_precision": "INTEGER"
     },
+    "dynamic_wi4_afp32_blockwise": {
+      "weight_tensor_config": {
+        "num_bits": 4,
+        "symmetric": [true],
+        "granularity": ["BLOCKWISE"],
+        "dtype": "INT",
+        "block_size": [32, 64, 96, 128, 256]
+      },
+      "explicit_dequantize": false,
+      "compute_precision": "INTEGER"
+    },
     "static_wi8_ai16": {
       "activation_tensor_config": {
         "num_bits": 16,
@@ -216,6 +227,7 @@ DEFAULT_JSON_POLICY = """
       "FULLY_CONNECTED"
     ],
     "dynamic_wi4_afp32": ["FULLY_CONNECTED", "EMBEDDING_LOOKUP", "CONV_2D"],
+    "dynamic_wi4_afp32_blockwise": ["EMBEDDING_LOOKUP", "FULLY_CONNECTED"],
     "weightonly_wi8_afp32": [
       "BATCH_MATMUL",
       "CONV_2D",
@@ -259,6 +271,7 @@ def _unroll_json_config(
 
   # Then unroll weight configs and turn them into quantization configs.
   quant_configs = []
+  weight_configs = []
   for symmetric in json_config["weight_tensor_config"]["symmetric"]:
     for granularity in json_config["weight_tensor_config"]["granularity"]:
       tensor_config = {
@@ -267,6 +280,16 @@ def _unroll_json_config(
           "granularity": granularity,
           "dtype": json_config["weight_tensor_config"]["dtype"],
       }
+      if "block_size" in json_config["weight_tensor_config"]:
+        for block_size in json_config["weight_tensor_config"]["block_size"]:
+          tensor_config["block_size"] = block_size
+          weight_configs.append(
+              qtyping.TensorQuantizationConfig.from_dict(tensor_config)
+          )
+      else:
+        weight_configs.append(
+            qtyping.TensorQuantizationConfig.from_dict(tensor_config)
+        )
 
       if activation_configs:
         for activation_config in activation_configs:
@@ -281,15 +304,14 @@ def _unroll_json_config(
               )
           )
       else:
-        quant_configs.append(
-            qtyping.OpQuantizationConfig(
-                weight_tensor_config=qtyping.TensorQuantizationConfig.from_dict(
-                    tensor_config
-                ),
-                compute_precision=json_config["compute_precision"],
-                explicit_dequantize=json_config["explicit_dequantize"],
-            )
-        )
+        for weight_config in weight_configs:
+          quant_configs.append(
+              qtyping.OpQuantizationConfig(
+                  weight_tensor_config=weight_config,
+                  compute_precision=json_config["compute_precision"],
+                  explicit_dequantize=json_config["explicit_dequantize"],
+              )
+          )
 
   return quant_configs
 

ai_edge_quantizer/params_generator.py

@@ -161,7 +161,7 @@ class ParamsGenerator:
       RuntimeError: If the tensors sharing the same buffer have different
       quantization settings.
     """
-    self._check_buffer_sharing()
+    self._check_and_fix_buffer_sharing()
 
   def _update_model_quant_results(
       self,
@@ -273,9 +273,11 @@ class ParamsGenerator:
     """Mark tensors that require buffer duplication.
 
     Marking a tensor means adding a DUPLICATE_BUFFER transformation as the first
-    transformation to be applied for each consumer of the tensor.
+    transformation to be applied for each consumer of the tensor. Need to do
+    that for each consumer to preserve a zero layer and not affect the
+    horizontal optimization later in the transformation instructions generator.
 
-    Mark all tensors within each of the provided buffers as requiring buffer
+    Marks all tensors within each of the provided buffers as requiring buffer
     duplication, except for the last tensor. The order of tensors is assumed to
     be the same during both the marking and transformation performer steps, as
     determined by `self.buffer_to_tensors`. This allows the final tensor to
@@ -292,65 +294,148 @@ class ParamsGenerator:
               0, _QuantTrans.DUPLICATE_BUFFER
           )
 
-  def _check_buffer_sharing(self) -> None:
-    """Check if tensors sharing the same buffer have the same quantization.
+  def _mark_tensors_requiring_tensor_duplication(
+      self, tensor_names_to_duplicate
+  ) -> None:
+    """Mark tensors that require tensor duplication.
+
+    Marking a tensor means adding a DUPLICATE_TENSOR transformation as the first
+    transformation to be applied for each consumer of the tensor. Need to do
+    that for each consumer to preserve a zero layer and not affect the
+    horizontal optimization later in the transformation instructions generator.
+
+    Args:
+      tensor_names_to_duplicate: Names of tensors to duplicate.
+    """
+    for tensor_name in tensor_names_to_duplicate:
+      for consumer_params in self.model_quant_results[tensor_name].consumers:
+        consumer_params.transformations.insert(0, _QuantTrans.DUPLICATE_TENSOR)
+
+  def _check_buffer_sharing_for_tensor(self, tensor: Any) -> bool:
+    """Check buffer sharing for the tensor against itself.
+
+    Args:
+      tensor: The tensor to check.
+
+    Returns:
+      Whether the tensor has compatible quantization parameters.
 
     Raises:
-      RuntimeError: If the tensors sharing the same buffer have different
-        quantization settings.
+      RuntimeError: If the tensor has incompatible quantization parameters
+      and the buffer is not constant.
     """
-    def get_result(tensor: Any):
-      return self.model_quant_results.get(
-          tfl_flatbuffer_utils.get_tensor_name(tensor), None
+    tensor_params = self.model_quant_results.get(
+        tfl_flatbuffer_utils.get_tensor_name(tensor), None
+    )
+    if tensor_params is None:
+      return True
+
+    if _are_tensor_consumer_params_compatible(tensor_params):
+      return True
+    elif _is_constant_tensor(tensor, self.flatbuffer_model.buffers):
+      return False
+    else:
+      error_msg = (
+          f'The tensor {tensor.name} consumers do not have the same'
+          ' quantization parameters. Please modify your quantization recipe to'
+          ' make sure the two tensors have the same quantization settings.'
       )
+      raise RuntimeError(error_msg)
 
-    buffers_to_duplicate = []
-    for tensors in self.buffer_to_tensors.values():
-      if not tensors:
-        continue
+  def _check_buffer_sharing_for_self_compatible_tensors(
+      self, tensor1: Any, tensor2: Any
+  ) -> bool:
+    """Check a pair of self compatible tensors have the same quantization params.
 
-      first_tensor = tensors[0]
-      first_tensor_params = get_result(first_tensor)
-      if first_tensor_params is None:
-        continue
+    Self compatible means that all tensor's consumers have the same quantization
+    parameters.
 
-      for tensor in tensors:  # Also checking against itself.
-        tensor_params = get_result(tensor)
-        if tensor_params is None:
-          continue
+    Args:
+      tensor1: The first tensor to check.
+      tensor2: The second tensor to check.
 
-        if not _compatible_tensor_transformation_params(
-            first_tensor_params, tensor_params
-        ):
-          if _are_distinct_tensors_with_shared_buffer(
-              first_tensor, tensor, self.flatbuffer_model.buffers
-          ):
-            buffers_to_duplicate.append(first_tensor.buffer)
-            break
-          else:
-            error_msg = (
-                f'The tensors {first_tensor.name} and {tensor.name} do not have'
-                ' the same quantization parameters even though they share the'
-                ' same buffer. Please modify your quantization recipe to make'
-                ' sure the two tensors have the same quantization settings.'
-            )
-            raise RuntimeError(error_msg)
+    Returns:
+      Whether the tensors have compatible quantization parameters.
 
-    self._mark_tensors_requiring_buffer_duplication(buffers_to_duplicate)
+    Raises:
+      RuntimeError: If the tensors have incompatible quantization parameters
+      and the buffer is not constant.
+    """
+    tensor1_params = self.model_quant_results.get(
+        tfl_flatbuffer_utils.get_tensor_name(tensor1), None
+    )
+    tensor2_params = self.model_quant_results.get(
+        tfl_flatbuffer_utils.get_tensor_name(tensor2), None
+    )
 
+    if tensor1_params is None or tensor2_params is None:
+      return True
 
-def _compatible_tensor_transformation_params(
-    params1: qtyping.TensorTransformationParams,
-    params2: qtyping.TensorTransformationParams,
-) -> bool:
-  """Check if two tensor transformation params are compatible."""
-  return (
-      _are_tensor_consumer_params_compatible(params1)
-      and _are_tensor_consumer_params_compatible(params2)
-      and _are_self_compatible_tensors_compatible_to_each_other(
-          params1, params2
+    if _are_self_compatible_tensors_compatible_to_each_other(
+        tensor1_params, tensor2_params
+    ):
+      return True
+    elif _is_constant_tensor(tensor1, self.flatbuffer_model.buffers):
+      return False
+    else:
+      error_msg = (
+          f'The tensors {tensor1.name} and {tensor2.name} do not have'
+          ' the same quantization parameters even though they share the'
+          ' same buffer. Please modify your quantization recipe to make'
+          ' sure the two tensors have the same quantization settings.'
       )
-  )
+      raise RuntimeError(error_msg)
+
+  def _check_and_fix_buffer_sharing(self) -> None:
+    """Check and fix tensor/buffer sharing issues when possible.
+
+    This function checks if tensors sharing the same buffer have the same
+    quantization settings. If not, when it's possible, it will fix it by marking
+    such tensors or buffers to be duplicated. Otherwise, it will raise an error.
+
+    Possible cases that can be fixed by duplication:
+      1. A constant tensor recieves different quantization parameters from its
+      consumers. In this case, the tensor is marked for duplication.
+      2. Two or more tensors share the same constant buffer and have different
+      quantization parameters. In this case, the buffer is marked for
+      duplication.
+
+    Raises:
+      RuntimeError: If the tensors sharing the same buffer have different
+        quantization settings and it can't be resolved by duplicating the
+        buffer/tensor.
+    """
+    buffers_to_duplicate = []
+    tensor_names_to_duplicate = []
+    for buffer_idx, tensors in self.buffer_to_tensors.items():
+      if not tensors:
+        continue
+      # Check if any of the tensors needs to be duplicated.
+      for tensor in tensors:
+        if not self._check_buffer_sharing_for_tensor(tensor):
+          tensor_names_to_duplicate.append(
+              tfl_flatbuffer_utils.get_tensor_name(tensor)
+          )
+      # Check if the buffer needs to be duplicated.
+      tensor_1 = tensors[0]
+      tensor_name_1 = tfl_flatbuffer_utils.get_tensor_name(tensor_1)
+      if tensor_name_1 in tensor_names_to_duplicate:
+        buffers_to_duplicate.append(buffer_idx)
+        continue
+      for tensor_2 in tensors[1:]:
+        tensor_name_2 = tfl_flatbuffer_utils.get_tensor_name(tensor_2)
+        if (
+            tensor_name_2 in tensor_names_to_duplicate
+            or not self._check_buffer_sharing_for_self_compatible_tensors(
+                tensor_1, tensor_2
+            )
+        ):
+          buffers_to_duplicate.append(buffer_idx)
+          break
+
+    # Fix the buffer sharing issues.
+    self._mark_tensors_requiring_buffer_duplication(buffers_to_duplicate)
+    self._mark_tensors_requiring_tensor_duplication(tensor_names_to_duplicate)
 
 
 def _are_tensor_consumer_params_compatible(
@@ -447,12 +532,6 @@ def _compatible_tensor_params(
   return False
 
 
-def _are_distinct_tensors_with_shared_buffer(
-    tensor1: Any, tensor2: Any, buffers: list[Any]
-) -> bool:
-  """Check if two tensors are different and share a constant buffer."""
-  are_different_tensors = tensor1.name != tensor2.name
-  do_share_buffer = tensor1.buffer == tensor2.buffer
-  is_constant_buffer = buffers[tensor1.buffer].data is not None
-
-  return are_different_tensors and do_share_buffer and is_constant_buffer
+def _is_constant_tensor(tensor: Any, buffers: Sequence[Any]) -> bool:
+  """Check if the tensor is a constant tensor."""
+  return buffers[tensor.buffer].data is not None

ai_edge_quantizer/params_generator_test.py

@@ -28,7 +28,6 @@ from ai_edge_quantizer import recipe_manager
 from ai_edge_quantizer.utils import test_utils
 from ai_edge_quantizer.utils import tfl_flatbuffer_utils
 from ai_edge_quantizer.utils import tfl_interpreter_utils
-from ai_edge_litert import schema_py_generated  # pylint: disable=g-direct-tensorflow-import
 
 
 _ComputePrecision = qtyping.ComputePrecision
@@ -654,12 +653,164 @@ class ParamsGeneratorTest(parameterized.TestCase):
               consumer.transformations[0],
               _QTransf.DUPLICATE_BUFFER,
           )
-      elif quant_params[tensor_name].consumers is not None:
-        for consumer in quant_params[tensor_name].consumers:
           self.assertNotIn(
-              _QTransf.DUPLICATE_BUFFER,
-              consumer.transformations,
+              _QTransf.DUPLICATE_BUFFER, consumer.transformations[1:]
           )
+      elif quant_params[tensor_name].consumers is not None:
+        for consumer in quant_params[tensor_name].consumers:
+          self.assertNotIn(_QTransf.DUPLICATE_BUFFER, consumer.transformations)
+
+  def _get_fc_recipe_entry(self, regex: str, num_bits: int):
+    return {
+        'regex': regex,
+        'operation': 'FULLY_CONNECTED',
+        'algorithm_key': 'min_max_uniform_quantize',
+        'op_config': {
+            'weight_tensor_config': {
+                'num_bits': num_bits,
+                'symmetric': True,
+                'granularity': 'CHANNELWISE',
+                'dtype': 'INT',
+                'block_size': 0,
+            },
+            'compute_precision': 'INTEGER',
+            'explicit_dequantize': False,
+            'skip_checks': False,
+            'min_weight_elements': 0,
+        },
+    }
+
+  @parameterized.named_parameters(
+      dict(
+          testcase_name='fc1_quant_fc2_no_quant',
+          fc1_num_bits=8,
+          fc2_num_bits=None,
+      ),
+      dict(
+          testcase_name='fc1_no_quant_fc2_quant',
+          fc1_num_bits=None,
+          fc2_num_bits=8,
+      ),
+      dict(
+          testcase_name='fc1_quant_fc2_quant_different_params',
+          fc1_num_bits=8,
+          fc2_num_bits=4,
+      ),
+  )
+  def test_generate_params_marks_correct_buffers_tensors_for_duplication(
+      self,
+      fc1_num_bits,
+      fc2_num_bits,
+  ):
+    model_path = os.path.join(
+        TEST_DATA_PREFIX_PATH,
+        'tests/models/constant_tensor_and_buffer_only_sharing_weight_fcs.tflite',
+    )
+    sig1_fc1_regex = 'BatchMatMulV3;'
+    sig1_fc2_regex = 'PartitionedCall:0;'
+    recipe = []
+    if fc1_num_bits is not None:
+      recipe.append(self._get_fc_recipe_entry(sig1_fc1_regex, fc1_num_bits))
+    if fc2_num_bits is not None:
+      recipe.append(self._get_fc_recipe_entry(sig1_fc2_regex, fc2_num_bits))
+    self._recipe_manager.load_quantization_recipe(recipe)
+    pg = params_generator.ParamsGenerator(model_path)
+    quant_params = pg.generate_quantization_parameters(self._recipe_manager)
+
+    expected_tensor = 'arith.constant'
+    consumers = quant_params[expected_tensor].consumers
+    self.assertLen(consumers, 2)
+
+    # Check FC1 transformations.
+    if fc1_num_bits is None:
+      fc1_quant_transformation = _QTransf.NO_QUANTIZE
+    else:
+      fc1_quant_transformation = _QTransf.QUANTIZE_TENSOR
+    self.assertEqual(
+        consumers[0].transformations,
+        [
+            _QTransf.DUPLICATE_TENSOR,
+            _QTransf.DUPLICATE_BUFFER,
+            fc1_quant_transformation,
+        ],
+    )
+    # Check FC2 transformations.
+    if fc2_num_bits is None:
+      fc2_quant_transformation = _QTransf.NO_QUANTIZE
+    else:
+      fc2_quant_transformation = _QTransf.QUANTIZE_TENSOR
+    self.assertEqual(
+        consumers[1].transformations,
+        [
+            _QTransf.DUPLICATE_TENSOR,
+            _QTransf.DUPLICATE_BUFFER,
+            fc2_quant_transformation,
+        ],
+    )
+    # Check that no other tensor has tensor or buffer duplication
+    # transformations.
+    for tensor_name, params in quant_params.items():
+      if tensor_name == expected_tensor:
+        continue
+      for consumer in params.consumers:
+        self.assertNotIn(_QTransf.DUPLICATE_TENSOR, consumer.transformations)
+        self.assertNotIn(_QTransf.DUPLICATE_BUFFER, consumer.transformations)
+
+  def test_generate_params_returns_valid_results_when_multiple_tensor_duplication_for_one_buffer(
+      self,
+  ):
+    model_path = os.path.join(
+        TEST_DATA_PREFIX_PATH,
+        'tests/models/constant_tensor_and_buffer_only_sharing_weight_fcs.tflite',
+    )
+    sig1_fc1_regex = 'BatchMatMulV3;'
+    sig1_fc2_regex = 'PartitionedCall:0;'
+    sig2_fc1_regex = 'BatchMatMulV31;'
+    sig2_fc2_regex = 'PartitionedCall_1:0;'
+    recipe = [
+        self._get_fc_recipe_entry(sig1_fc1_regex, num_bits=8),
+        self._get_fc_recipe_entry(sig1_fc2_regex, num_bits=4),
+        self._get_fc_recipe_entry(sig2_fc1_regex, num_bits=8),
+        self._get_fc_recipe_entry(sig2_fc2_regex, num_bits=4),
+    ]
+    self._recipe_manager.load_quantization_recipe(recipe)
+    pg = params_generator.ParamsGenerator(model_path)
+    quant_params = pg.generate_quantization_parameters(self._recipe_manager)
+    # Check transformations for sig1.
+    sig1_expected_tensor = 'arith.constant'
+    sig1_consumers = quant_params[sig1_expected_tensor].consumers
+    self.assertLen(sig1_consumers, 2)
+    sig1_expected_transformations = [
+        _QTransf.DUPLICATE_TENSOR,
+        _QTransf.DUPLICATE_BUFFER,
+        _QTransf.QUANTIZE_TENSOR,
+    ]
+    for sig1_consumer in sig1_consumers:
+      self.assertEqual(
+          sig1_consumer.transformations,
+          sig1_expected_transformations,
+      )
+    # Check transformations for sig2.
+    sig2_expected_tensor = 'arith.constant1'
+    sig2_consumers = quant_params[sig2_expected_tensor].consumers
+    self.assertLen(sig2_consumers, 2)
+    sig2_expected_transformations = [
+        _QTransf.DUPLICATE_TENSOR,
+        _QTransf.QUANTIZE_TENSOR,
+    ]
+    for sig2_consumer in sig2_consumers:
+      self.assertEqual(
+          sig2_consumer.transformations,
+          sig2_expected_transformations,
+      )
+    # Check that no other tensor has tensor or buffer duplication
+    # transformations.
+    for tensor_name, params in quant_params.items():
+      if tensor_name in [sig1_expected_tensor, sig2_expected_tensor]:
+        continue
+      for consumer in params.consumers:
+        self.assertNotIn(_QTransf.DUPLICATE_TENSOR, consumer.transformations)
+        self.assertNotIn(_QTransf.DUPLICATE_BUFFER, consumer.transformations)
 
   @parameterized.named_parameters(
       dict(
@@ -996,62 +1147,5 @@ class ParamsGeneratorAlreadyQuantizedModelTest(googletest.TestCase):
       _ = params_generator.ParamsGenerator(test_model_path)
 
 
-def _create_tensor(name: str, buffer_idx: int) -> schema_py_generated.TensorT:
-  tensor = schema_py_generated.TensorT()
-  tensor.name = name.encode('utf-8')
-  tensor.buffer = buffer_idx
-  return tensor
-
-
-def _create_buffer(data: Any) -> schema_py_generated.BufferT:
-  buffer = schema_py_generated.BufferT()
-  buffer.data = data
-  return buffer
-
-
-class ParamsGeneratorUtilsTest(parameterized.TestCase):
-
-  @parameterized.named_parameters(
-      dict(
-          testcase_name='same_tensors',
-          tensor1=_create_tensor(name='tensor1', buffer_idx=0),
-          tensor2=_create_tensor(name='tensor1', buffer_idx=0),
-          buffers=[_create_buffer(data=np.array([1, 2, 3]))],
-          expected=False,
-      ),
-      dict(
-          testcase_name='tensors_do_not_share_buffer',
-          tensor1=_create_tensor(name='tensor1', buffer_idx=0),
-          tensor2=_create_tensor(name='tensor2', buffer_idx=1),
-          buffers=[
-              _create_buffer(data=np.array([1, 2, 3])),
-              _create_buffer(data=np.array([4, 5, 6])),
-          ],
-          expected=False,
-      ),
-      dict(
-          testcase_name='different_tensors_share_non_constant_buffer',
-          tensor1=_create_tensor(name='tensor1', buffer_idx=0),
-          tensor2=_create_tensor(name='tensor2', buffer_idx=0),
-          buffers=[_create_buffer(data=None)],
-          expected=False,
-      ),
-      dict(
-          testcase_name='different_tensors_share_constant_buffer',
-          tensor1=_create_tensor(name='tensor1', buffer_idx=0),
-          tensor2=_create_tensor(name='tensor2', buffer_idx=0),
-          buffers=[_create_buffer(data=np.array([1, 2, 3]))],
-          expected=True,
-      ),
-  )
-  def test__are_distinct_tensors_with_shared_buffer(
-      self, tensor1, tensor2, buffers, expected
-  ):
-    got = params_generator._are_distinct_tensors_with_shared_buffer(
-        tensor1=tensor1, tensor2=tensor2, buffers=buffers
-    )
-    self.assertEqual(expected, got)
-
-
 if __name__ == '__main__':
   googletest.main()

{ai_edge_quantizer_nightly-0.1.0.dev20250411.dist-info → ai_edge_quantizer_nightly-0.1.0.dev20250413.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-edge-quantizer-nightly
-Version: 0.1.0.dev20250411
+Version: 0.1.0.dev20250413
 Summary: A quantizer for advanced developers to quantize converted AI Edge models.
 Home-page: https://github.com/google-ai-edge/ai-edge-quantizer
 Keywords: On-Device ML,AI,Google,TFLite,Quantization,LLMs,GenAI

{ai_edge_quantizer_nightly-0.1.0.dev20250411.dist-info → ai_edge_quantizer_nightly-0.1.0.dev20250413.dist-info}/RECORD

@@ -1,17 +1,17 @@
 ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
 ai_edge_quantizer/algorithm_manager.py,sha256=0uootLsVD6h9ph9TrnXZMI-ExkX8UvXSV0lbWxBLybU,10492
 ai_edge_quantizer/algorithm_manager_api.py,sha256=u903TG0s1uIDhJqfeJne3CFl8A93phZrwgV2-hwdcXU,9247
-ai_edge_quantizer/algorithm_manager_api_test.py,sha256=tL_ozYFTsOPX8qGcti0KTz37nVsCxf0SSG5C45SyT-g,7319
+ai_edge_quantizer/algorithm_manager_api_test.py,sha256=w6bSONvXkX6bzXAGc0-7b6gNDt9oz9ieq97KP8Sg_JU,7666
 ai_edge_quantizer/calibrator.py,sha256=n7AD9j7UScR-CieoI6DQRMeiG_fhLBfSLRiM4460xaM,11895
 ai_edge_quantizer/calibrator_test.py,sha256=C_oWOaRugPKYX74jF-eRFH-k6nGOdA8I9_uPiocaOuE,11900
 ai_edge_quantizer/conftest.py,sha256=SxCz-5LlRD_lQm4hQc4c6IGG7DS8d7IyEWY9gnscPN0,794
-ai_edge_quantizer/default_policy.py,sha256=2y9p7iZIESB4ozPwjiodgPTLlnmHxQKkwKcYSfc80JI,10277
+ai_edge_quantizer/default_policy.py,sha256=81z4cruBK7mGFt8xFRZK5LKya65axuZwo2zpbcYSicc,11099
 ai_edge_quantizer/model_modifier.py,sha256=SPt9X-xBzRvcd4xIS24zLHt3aUS2QwsNDqweFqitCAo,7109
 ai_edge_quantizer/model_modifier_test.py,sha256=cJd04SLOG-fQZZNZPcisoBLx3cLtWEwGqUBbLb-pif4,4751
 ai_edge_quantizer/model_validator.py,sha256=fRNz0jO54cthPTibsCuViUXUuFRHl_fbvEiCukIVy20,13030
 ai_edge_quantizer/model_validator_test.py,sha256=EeqOP_mrZsnZ3rug756s0ryDDqd2KgIDld5Lm_gDuWY,13020
-ai_edge_quantizer/params_generator.py,sha256=PeIwoNYg4kJq0cMPucTvyxXTqD0I1Sr8vm5xHZCQ518,16774
-ai_edge_quantizer/params_generator_test.py,sha256=DhULRWs1-UuO55zuuxocMjWDClcjcaKaue6mOcoHq9E,37186
+ai_edge_quantizer/params_generator.py,sha256=NEZeHVVIeynmhRzPjl9o-acvWfauFgCS4i45pWFw3V8,20052
+ai_edge_quantizer/params_generator_test.py,sha256=RDYoRZDJfEZRtjlTAU2kZ_4t3JHOqEHxfJX9V4ETAhg,40597
 ai_edge_quantizer/qtyping.py,sha256=FqelZu7j0fGBRSCv_VVsuf3VmbfVlYJGgsjvdMXGgaw,15284
 ai_edge_quantizer/quantizer.py,sha256=g3DMqFMrMpt9jQttCE0WcdNbMtk0JZnmN5MmCHrNdyM,13202
 ai_edge_quantizer/quantizer_test.py,sha256=K_HBA56JkFI3HL8VLWCqGEfC0ISh5ldMKoNyBdGRAJg,20368
@@ -66,8 +66,8 @@ ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=x2xA2CFPpe_2trcV8v5xGaBE
 ai_edge_quantizer/utils/tfl_interpreter_utils_test.py,sha256=Op3JxtOqlrjzmYF18jnnstL1k9xiY9kKJ8S2vklKGkc,11327
 ai_edge_quantizer/utils/validation_utils.py,sha256=oYw33Sg547AqtGw-choPUJmp9SAKkV46J_ddqSsum2Q,3950
 ai_edge_quantizer/utils/validation_utils_test.py,sha256=V_qNDikPD4OPB-siOLQCWNVWTAu87h2IgNYt7teFd-o,2934
-ai_edge_quantizer_nightly-0.1.0.dev20250411.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.1.0.dev20250411.dist-info/METADATA,sha256=QZOnAd8Qw8RSuM07O8fXlGp_E5XrPwO9MeISmmCZg78,1527
-ai_edge_quantizer_nightly-0.1.0.dev20250411.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ai_edge_quantizer_nightly-0.1.0.dev20250411.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.1.0.dev20250411.dist-info/RECORD,,
+ai_edge_quantizer_nightly-0.1.0.dev20250413.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.1.0.dev20250413.dist-info/METADATA,sha256=6aamAYoiKg6FpaZrdP1NXEL-fIWLbvhdkqgc326TYtw,1527
+ai_edge_quantizer_nightly-0.1.0.dev20250413.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+ai_edge_quantizer_nightly-0.1.0.dev20250413.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.1.0.dev20250413.dist-info/RECORD,,