ai-edge-quantizer-nightly 0.0.1.dev20250312__py3-none-any.whl → 0.0.1.dev20250314__py3-none-any.whl

ai_edge_quantizer/model_modifier.py

@@ -15,6 +15,7 @@
 
 """Model Modifier class that produce the final quantized TFlite model."""
 
+from collections.abc import Sequence
 import copy
 
 import numpy as np
@@ -22,6 +23,7 @@ import numpy as np
 from ai_edge_quantizer import qtyping
 from ai_edge_quantizer import transformation_instruction_generator
 from ai_edge_quantizer import transformation_performer
+from ai_edge_quantizer.utils import tfl_flatbuffer_utils
 from ai_edge_litert import schema_py_generated  # pylint: disable=g-direct-tensorflow-import
 from tensorflow.lite.tools import flatbuffer_utils  # pylint: disable=g-direct-tensorflow-import
 
@@ -46,6 +48,35 @@ class ModelModifier:
         transformation_performer.TransformationPerformer()
     )
 
+  def _get_tensor_processing_order(
+      self,
+      tensor_names: Sequence[str],
+      flatbuffer_model: schema_py_generated.ModelT,
+  ) -> list[str]:
+    """Get the tensor processing order obtained from `buffer_to_tensors`.
+
+    The processing order is used to ensure that last tensor in a buffer is
+    processed the last. This is required for the correctness of buffer
+    duplication, as the last tensor in a buffer won't be duplicated.
+
+    Args:
+      tensor_names: Names of the tensors that need to be processed.
+      flatbuffer_model: TFlite model.
+
+    Returns:
+      A list of tensor names in the processing order.
+    """
+    buffer_to_tensors = tfl_flatbuffer_utils.buffer_to_tensors(flatbuffer_model)
+
+    processing_order = []
+    for buffer_tensors in buffer_to_tensors.values():
+      for tensor in buffer_tensors:
+        tensor_name = tfl_flatbuffer_utils.get_tensor_name(tensor)
+        if tensor_name in tensor_names:
+          processing_order.append(tensor_name)
+
+    return processing_order
+
   def modify_model(
       self, params: dict[str, qtyping.TensorTransformationParams]
   ) -> bytearray:
@@ -66,8 +97,11 @@ class ModelModifier:
         params, quantized_model
     )
 
+    tensor_processing_order = self._get_tensor_processing_order(
+        list(instructions.keys()), quantized_model
+    )
     self._transformation_performer.transform_graph(
-        instructions, quantized_model
+        instructions, quantized_model, tensor_processing_order
     )
     constant_buffer_size = self._process_constant_map(quantized_model)
     # we leave 64MB for the model architecture.

ai_edge_quantizer/params_generator.py

@@ -15,6 +15,7 @@
 
 """Generate model tensor level quantization config."""
 
+from collections.abc import Sequence
 import copy
 from typing import Any, Optional, Union
 
@@ -266,6 +267,31 @@ class ParamsGenerator:
         tensor_params.append(output_tensor_params)
     return tensor_params
 
+  def _mark_tensors_requiring_buffer_duplication(
+      self, buffers_to_duplicate: Sequence[int]
+  ) -> None:
+    """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.
+
+    Mark 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
+    reuse the original buffer, as it is not marked for duplication.
+
+    Args:
+      buffers_to_duplicate: Indices of the buffers to duplicate.
+    """
+    for buffer_idx in buffers_to_duplicate:
+      for tensor in self.buffer_to_tensors[buffer_idx][:-1]:
+        tensor_name = tfl_flatbuffer_utils.get_tensor_name(tensor)
+        for consumer_params in self.model_quant_results[tensor_name].consumers:
+          consumer_params.transformations.insert(
+              0, _QuantTrans.DUPLICATE_BUFFER
+          )
+
   def _check_buffer_sharing(self) -> None:
     """Check if tensors sharing the same buffer have the same quantization.
 
@@ -278,6 +304,7 @@ class ParamsGenerator:
           tfl_flatbuffer_utils.get_tensor_name(tensor), None
       )
 
+    buffers_to_duplicate = []
     for tensors in self.buffer_to_tensors.values():
       if len(tensors) <= 1:
         continue
@@ -295,13 +322,21 @@ class ParamsGenerator:
         if not _compatible_tensor_transformation_params(
             first_tensor_params, tensor_params
         ):
-          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)
+          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)
+
+    self._mark_tensors_requiring_buffer_duplication(buffers_to_duplicate)
 
 
 def _compatible_tensor_transformation_params(
@@ -381,3 +416,14 @@ def _compatible_tensor_params(
   ):
     return True
   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

ai_edge_quantizer/params_generator_test.py

@@ -13,8 +13,6 @@
 # limitations under the License.
 # ==============================================================================
 
-"""Tests for params_generator."""
-
 from collections.abc import Generator
 import os
 from typing import Any
@@ -30,6 +28,7 @@ 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
@@ -570,9 +569,27 @@ class ParamsGeneratorTest(parameterized.TestCase):
     )
     self.assertLen(quant_params, 6)
 
-  @parameterized.parameters('no_quant', 'execution_mode', 'num_bits')
-  def test_generate_params_buffer_sharing_graphs_fails(
-      self, the_other_fc_difference
+  @parameterized.named_parameters(
+      dict(
+          testcase_name='different_quant_config_fc2_no_quant',
+          fc_2_num_bits=None,
+          expected_tensor_with_buffer_duplication='BatchMatMulV3',
+      ),
+      dict(
+          testcase_name='different_quant_config_fc2_int4',
+          fc_2_num_bits=4,
+          expected_tensor_with_buffer_duplication='BatchMatMulV3',
+      ),
+      dict(
+          testcase_name='same_quant_config',
+          fc_2_num_bits=8,
+          expected_tensor_with_buffer_duplication=None,
+      ),
+  )
+  def test_generate_params_marks_correct_buffers_for_duplication_when_distinct_tensors_share_constant_buffer(
+      self,
+      fc_2_num_bits,
+      expected_tensor_with_buffer_duplication,
   ):
     model_path = os.path.join(
         TEST_DATA_PREFIX_PATH, 'tests/models/weight_sharing_fcs.tflite'
@@ -580,33 +597,52 @@ class ParamsGeneratorTest(parameterized.TestCase):
     # Setup the quantization config for the first FC.
     self._recipe_manager.add_quantization_config(
         regex='PartitionedCall:0',
-        operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+        operation_name=qtyping.TFLOperationName.FULLY_CONNECTED,
         op_config=qtyping.OpQuantizationConfig(
-            weight_tensor_config=_TensorQuantConfig(num_bits=8),
+            weight_tensor_config=_TensorQuantConfig(
+                num_bits=8, granularity=qtyping.QuantGranularity.CHANNELWISE
+            ),
             compute_precision=_ComputePrecision.INTEGER,
         ),
     )
     # Setup the quantization config for the second FC (weight shared with the
     # first FC).
-    if the_other_fc_difference == 'no_quant':
-      pass
-    elif the_other_fc_difference == 'num_bits':
+    if fc_2_num_bits is not None:
       self._recipe_manager.add_quantization_config(
           regex='PartitionedCall_1:0',
-          operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+          operation_name=qtyping.TFLOperationName.FULLY_CONNECTED,
           op_config=qtyping.OpQuantizationConfig(
-              weight_tensor_config=_TensorQuantConfig(num_bits=4),
+              weight_tensor_config=_TensorQuantConfig(
+                  num_bits=fc_2_num_bits,
+                  granularity=qtyping.QuantGranularity.CHANNELWISE,
+              ),
               compute_precision=_ComputePrecision.INTEGER,
           ),
       )
     pg = params_generator.ParamsGenerator(model_path)
-    error_message = 'do not have the same quantization parameters'
-    with self.assertRaisesWithPredicateMatch(
-        RuntimeError, lambda err: error_message in str(err)
-    ):
-      pg.generate_quantization_parameters(
-          self._recipe_manager,
-      )
+    quant_params = pg.generate_quantization_parameters(
+        self._recipe_manager,
+    )
+    self.assertLen(quant_params, 6)
+
+    # Check that the expected tensor has buffer duplication transformation as
+    # the first one to be applied. And no other tensor has buffer duplication
+    # transformation at all.
+    for tensor_name in quant_params:
+      if tensor_name == expected_tensor_with_buffer_duplication:
+        self.assertIsNotNone(quant_params[tensor_name].consumers)
+        for consumer in quant_params[tensor_name].consumers:
+          self.assertNotEmpty(consumer.transformations)
+          self.assertEqual(
+              consumer.transformations[0],
+              qtyping.QuantTransformation.DUPLICATE_BUFFER,
+          )
+      elif quant_params[tensor_name].consumers is not None:
+        for consumer in quant_params[tensor_name].consumers:
+          self.assertNotIn(
+              qtyping.QuantTransformation.DUPLICATE_BUFFER,
+              consumer.transformations,
+          )
 
   @parameterized.named_parameters(
       dict(
@@ -1037,5 +1073,62 @@ 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/quantizer_test.py

@@ -412,7 +412,9 @@ class QuantizerMultiSignatureModelTest(parameterized.TestCase):
     available_signatures = validation_result.available_signature_keys()
     self.assertLen(available_signatures, 2)
 
-  def test_recipe_conflict_raises_error(self):
+  def test_constant_buffer_shared_by_tensors_with_different_quantization_params_succeeds(
+      self,
+  ):
     recipe = [
         dict({
             'regex': '.*',
@@ -439,17 +441,9 @@ class QuantizerMultiSignatureModelTest(parameterized.TestCase):
             },
         })
     ]
-
     qt = quantizer.Quantizer(self._test_model_path, recipe)
     calib_result = qt.calibrate(_MULTI_SIGNATURE_CALIBRATION_DATASET)
-
-    error_message = (
-        "The tensors b'Add/y' and b'Mul/y' do not have the same quantization"
-    )
-    with self.assertRaisesWithPredicateMatch(
-        RuntimeError, lambda err: error_message in str(err)
-    ):
-      qt.quantize(calib_result)
+    self.assertIsNotNone(qt.quantize(calib_result).quantized_model)
 
   def test_quantization_with_insufficient_calibration(self):
     # Run calibration for one signature only.

ai_edge_quantizer/transformation_instruction_generator_test.py

@@ -1077,6 +1077,68 @@ class InstructionGeneratorTest(parameterized.TestCase):
     self.assertLen(instructions, 1)
     self.assertEqual(instructions["tfl.quantize"], expected_instructions)
 
+  def test_instruction_generator_keeps_buffer_duplication_as_first_transformation(
+      self,
+  ):
+    test_tensor_name = "test_tensor"
+
+    dummy_quant_params = qtyping.UniformQuantParams(
+        8, None, np.array([1]), np.array([0])
+    )
+    consumer_params_1 = qtyping.OpToTensorParams(
+        subgraph_op_id=0,
+        transformations=[
+            qtyping.QuantTransformation.DUPLICATE_BUFFER,
+            qtyping.QuantTransformation.ADD_QUANTIZE,
+        ],
+        parameters=dummy_quant_params,
+    )
+    consumer_params_2 = qtyping.OpToTensorParams(
+        subgraph_op_id=2,
+        transformations=[
+            qtyping.QuantTransformation.DUPLICATE_BUFFER,
+            qtyping.QuantTransformation.ADD_QUANTIZE,
+            qtyping.QuantTransformation.ADD_DEQUANTIZE,
+        ],
+        parameters=dummy_quant_params,
+    )
+
+    quant_parameters = {
+        test_tensor_name: qtyping.TensorTransformationParams(
+            tensor_name=test_tensor_name,
+            producer=None,
+            consumers=[consumer_params_1, consumer_params_2],
+        ),
+    }
+    instruction_gen = (
+        instruction_generator.TransformationInstructionsGenerator()
+    )
+    # _tensor_name_to_graph_info has to have an entry for the test tensor for
+    # `quant_params_to_transformation_insts` to work. But the values do not
+    # matter for this test.
+    instruction_gen._tensor_name_to_graph_info[test_tensor_name] = (
+        instruction_generator.TransformationInstructionsGenerator.TensorGraphInfo(
+            tensor_id=1,
+            subgraph_id=0,
+            producer=0,
+            consumers=[2],
+        )
+    )
+    instructions = instruction_gen.quant_params_to_transformation_insts(
+        quant_parameters
+    )
+    self.assertLen(instructions, 1)
+    instructions = instructions[test_tensor_name].instructions
+    self.assertGreater(len(instructions), 1)
+    self.assertEqual(
+        instructions[0].transformation,
+        qtyping.QuantTransformation.DUPLICATE_BUFFER,
+    )
+    self.assertNotIn(
+        qtyping.QuantTransformation.DUPLICATE_BUFFER,
+        instructions[1:],
+    )
+
 
 if __name__ == "__main__":
   googletest.main()

ai_edge_quantizer/transformation_performer.py

@@ -15,7 +15,11 @@
 
 """Python manager for transformations to be applied to TFlite models."""
 
+from collections.abc import Sequence
+from typing import Optional
+
 import numpy as np
+
 from ai_edge_quantizer import qtyping
 from ai_edge_quantizer.transformations import dequant_insert
 from ai_edge_quantizer.transformations import duplicate_buffer
@@ -265,19 +269,24 @@ class TransformationPerformer:
       self,
       transformation_instructions: dict[str, qtyping.TensorTransformationInsts],
       tflite_model: schema_py_generated.ModelT,
-  ):
-    """Apply all transformations to the given tflite_model.
+      tensor_processing_order: Optional[Sequence[str]] = None,
+  ) -> None:
+    """Apply all transformations to the given tflite_model in place.
 
     Args:
-      transformation_instructions: a dict of transformation instructions grouped
-        by tensors, produced by transformation_instruction_generator
-      tflite_model: the tflite model to apply quantization on
-
-    Returns:
-      None, modifies the input tflite_model in place
+      transformation_instructions: Mapping from tensor name to its
+        transformation instructions, produced by
+        transformation_instruction_generator.
+      tflite_model: The tflite model to apply quantization to.
+      tensor_processing_order: The order of tensors to process. If not provided,
+        the order will be inferred from `transformation_instructions`.
     """
     self._original_op_id_map = []
     self._added_op_id_map = []
     self._create_op_id_map(tflite_model)
-    for transformation_inst in transformation_instructions.values():
-      self._apply_transformations(transformation_inst, tflite_model)
+    if tensor_processing_order is None:
+      tensor_processing_order = transformation_instructions.keys()
+    for tensor_name in tensor_processing_order:
+      self._apply_transformations(
+          transformation_instructions[tensor_name], tflite_model
+      )

ai_edge_quantizer/transformations/quantize_tensor.py

@@ -149,7 +149,7 @@ def _perform_blockwise_quantization(
       transformation_input.subgraph,
       transformation_input.buffers,
   )
-  blockwise_details.scale = scale_tensor_id
+  blockwise_details.scales = scale_tensor_id
   blockwise_details.blockSize = transformation_input.quant_params.block_size
   # blockwise quantization allows optional zero point.
   if transformation_input.quant_params.zero_point is not None:
@@ -160,7 +160,7 @@ def _perform_blockwise_quantization(
         transformation_input.subgraph,
         transformation_input.buffers,
     )
-    blockwise_details.zeroPoint = zero_point_tensor_id
+    blockwise_details.zeroPoints = zero_point_tensor_id
   flatbuffer_quantization.details = blockwise_details
   return flatbuffer_quantization
 

ai_edge_quantizer/transformations/quantize_tensor_test.py

@@ -168,8 +168,8 @@ class QuantizeTensorTest(parameterized.TestCase):
     )
     self.assertEqual(quant_param.details.blockSize, 32)
     # Check if the scale and zero point tensors are inserted correctly.
-    self.assertEqual(quant_param.details.scale, 9)
-    self.assertEqual(quant_param.details.zeroPoint, 10)
+    self.assertEqual(quant_param.details.scales, 9)
+    self.assertEqual(quant_param.details.zeroPoints, 10)
 
   def test_int4_constant_packed_correctly(self):
     subgraph = self._model.subgraphs[0]

{ai_edge_quantizer_nightly-0.0.1.dev20250312.dist-info → ai_edge_quantizer_nightly-0.0.1.dev20250314.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-edge-quantizer-nightly
-Version: 0.0.1.dev20250312
+Version: 0.0.1.dev20250314
 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.0.1.dev20250312.dist-info → ai_edge_quantizer_nightly-0.0.1.dev20250314.dist-info}/RECORD

@@ -6,22 +6,22 @@ ai_edge_quantizer/calibrator.py,sha256=n7AD9j7UScR-CieoI6DQRMeiG_fhLBfSLRiM4460x
 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/model_modifier.py,sha256=Z8EYtrz4zhCFpzd1zVwl2AetVE3BGBf5OvB2DbVQuds,5850
+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=wT_TyW9jIaOfvLr9a1JR_kxwZtPXCvDFF0n_2QcrDZg,14087
-ai_edge_quantizer/params_generator_test.py,sha256=d9JwR-yxNJgg1SW-m8sFFPkIRdhgsDwMpVKsBQFL0gg,37658
+ai_edge_quantizer/params_generator.py,sha256=jOCK2UuEsnnbqtbmLxUBpjmhsXZXjZZto2vdsPifliU,16039
+ai_edge_quantizer/params_generator_test.py,sha256=zmDS6jG5zKhHL_hzJw2wlMTx1LLcNCK6S5WlwogWF-A,41122
 ai_edge_quantizer/qtyping.py,sha256=UBZ3HgO8IDLY6VJmO05rGtFv_idMD3Os3WWsnriA0NA,15235
 ai_edge_quantizer/quantizer.py,sha256=g3DMqFMrMpt9jQttCE0WcdNbMtk0JZnmN5MmCHrNdyM,13202
-ai_edge_quantizer/quantizer_test.py,sha256=38oTMJwMmxwPDeqT3eaVbazjtuIUIzMQ3mJNKh_eNQY,20493
+ai_edge_quantizer/quantizer_test.py,sha256=K_HBA56JkFI3HL8VLWCqGEfC0ISh5ldMKoNyBdGRAJg,20368
 ai_edge_quantizer/recipe.py,sha256=r5tJiUs-ihZFzeK_jP2sUIUgTqZsL5SWvbUokuIUPDo,2251
 ai_edge_quantizer/recipe_manager.py,sha256=qcGUD7e7BISKdsY9WH2rdaRR3acmzSA5qMezGNbzlpo,8931
 ai_edge_quantizer/recipe_manager_test.py,sha256=LulVxsYp6TBGFI2PLCUCd4VsFq8ELpC7kMNkUjsLgbo,32230
 ai_edge_quantizer/recipe_test.py,sha256=Fg_sfxovI2fRjk5qdu18ghOvXdUvhDR1TxbE0GHDczc,3381
 ai_edge_quantizer/transformation_instruction_generator.py,sha256=WkECCO85lLs4cEnjZF5eVGbtuul4P8N77gUxUCK9ESY,21605
-ai_edge_quantizer/transformation_instruction_generator_test.py,sha256=23MfOBiXv5Wq9FKJen7DrJ66T58qxf4ECriIY7V013k,39113
-ai_edge_quantizer/transformation_performer.py,sha256=4GCCOw5WBhO0UUfFoLlbfUh3RfnffF9qI_yEpdWlyps,11181
+ai_edge_quantizer/transformation_instruction_generator_test.py,sha256=-6ycvqpLoAMRvHuLiAwNBZNhsWqwWTsi9tqFxV9Gfq0,41218
+ai_edge_quantizer/transformation_performer.py,sha256=y7kBTwXO_ORTBiijBv3y-L85Y-NwaDEIx3_OdI0uhUI,11551
 ai_edge_quantizer/transformation_performer_test.py,sha256=m3V6nd6jsjd6jVId5wTBNuyDB2h2p4tHlMWhlnomlJo,13341
 ai_edge_quantizer/algorithms/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
 ai_edge_quantizer/algorithms/nonlinear_quantize/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
@@ -48,8 +48,8 @@ ai_edge_quantizer/transformations/emulated_subchannel.py,sha256=HVaRxoC8PCAvy3xe
 ai_edge_quantizer/transformations/emulated_subchannel_test.py,sha256=gZP6u9NdPXl7s19qB_Un8evou9ZZV6I9Gy0E1rdobHM,7722
 ai_edge_quantizer/transformations/quant_insert.py,sha256=jn6HsJaV-sqBiFPY-Aqbd64t8zgcYVkEkZI375x_FWY,3958
 ai_edge_quantizer/transformations/quant_insert_test.py,sha256=X9ptPDvJCFkR5tejKnD1SlHFGPazQTW-wNNMV9MEAuw,10107
-ai_edge_quantizer/transformations/quantize_tensor.py,sha256=6CyUFR7fGmzbS-mSuDlSSCJJGxY9X_WnCmEuKqL4LzQ,7864
-ai_edge_quantizer/transformations/quantize_tensor_test.py,sha256=QnJmQ_-XN5X0oR57FoY9bWGTp7migf11psbdO9R2pLg,9050
+ai_edge_quantizer/transformations/quantize_tensor.py,sha256=9YaaWR6osxZoyUM8DUPJr_AjWO0QuNhFc65OFnSGzY4,7866
+ai_edge_quantizer/transformations/quantize_tensor_test.py,sha256=XZOollD1jnpCb78gMZx7yocF7RDBSf9HIf-XdG-y_io,9052
 ai_edge_quantizer/transformations/transformation_utils.py,sha256=R42OIbzwQ7JYJ-Qt46jsqwb6u4MfDGiIPCRZCUGLVCw,4664
 ai_edge_quantizer/transformations/transformation_utils_test.py,sha256=xH64SF3UHDh84vYbt-WvmXNjM-Jg-mefES1ACO1tkqw,6269
 ai_edge_quantizer/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
@@ -62,8 +62,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.0.1.dev20250312.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.0.1.dev20250312.dist-info/METADATA,sha256=ZRyM3EF8KAmJpo0QjIpL6Lv1qPQ_2tGLP4o_ARspijs,1528
-ai_edge_quantizer_nightly-0.0.1.dev20250312.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ai_edge_quantizer_nightly-0.0.1.dev20250312.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.0.1.dev20250312.dist-info/RECORD,,
+ai_edge_quantizer_nightly-0.0.1.dev20250314.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.0.1.dev20250314.dist-info/METADATA,sha256=UNaa9lN2B7kTFialdSIO7W9Dmr1wY9HSyj9ab-8egYk,1528
+ai_edge_quantizer_nightly-0.0.1.dev20250314.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+ai_edge_quantizer_nightly-0.0.1.dev20250314.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.0.1.dev20250314.dist-info/RECORD,,