ai-edge-quantizer-nightly 0.5.0.dev20251209__py3-none-any.whl → 0.5.0.dev20251211__py3-none-any.whl

ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py

@@ -36,6 +36,13 @@ _OpQuantConstraint = common_utils.OpQuantConstraint
 _ComputePrecision = qtyping.ComputePrecision
 
 
+def check_if_quantized(tensor: Any) -> bool:
+  """Checks if the tensor is quantized."""
+  return (
+      tensor.quantization is not None and tensor.quantization.scale is not None
+  )
+
+
 def check_op_quantization_config(
     op_name: _TFLOpName,
     op_quant_config: qtyping.OpQuantizationConfig,
@@ -271,7 +278,7 @@ def materialize_average_pool_2d(
   )
 
 
-def _materialize_bias_for_conv_ops(
+def _materialize_bias_for_fc_conv_ops(
     op_info: qtyping.OpInfo,
     graph_info: qtyping.GraphInfo,
     op_tensor_params: list[qtyping.TensorTransformationParams],
@@ -290,14 +297,16 @@ def _materialize_bias_for_conv_ops(
     op_weight_index: Index for the weight tensor in the op.
     op_bias_index: Index for the bias tensor in the op.
   """
-  _, _, bias_tensor, _ = tfl_flatbuffer_utils.parse_fc_bmm_conv_tensors(
-      op_info.op,
-      graph_info.subgraph_tensors,
-      op_input_index,
-      op_weight_index,
-      op_bias_index,
+  _, weight_tensor, bias_tensor, _ = (
+      tfl_flatbuffer_utils.parse_fc_bmm_conv_tensors(
+          op_info.op,
+          graph_info.subgraph_tensors,
+          op_input_index,
+          op_weight_index,
+          op_bias_index,
+      )
   )
-  if bias_tensor is not None:
+  if bias_tensor is not None and not check_if_quantized(bias_tensor):
     bias_quant_params = None
     # Fused bias needs to be quantized for SRQ.
     # Check if SRQ.
@@ -315,6 +324,19 @@ def _materialize_bias_for_conv_ops(
       weight_consumer_params = (
           op_tensor_params[op_weight_index].consumers[0].parameters
       )
+      if weight_consumer_params is None and check_if_quantized(weight_tensor):
+        quant_params = weight_tensor.quantization
+        if op_info.op_quant_config.weight_tensor_config is None:
+          raise ValueError(
+              "weight_tensor_config cannot be None when weight tensor is"
+              " quantized."
+          )
+        weight_consumer_params = qtyping.UniformQuantParams(
+            num_bits=op_info.op_quant_config.weight_tensor_config.num_bits,
+            scale=quant_params.scale,
+            zero_point=quant_params.zeroPoint,
+            quantized_dimension=quant_params.quantizedDimension,
+        )
       try:
         # Bias quantization is using fixed quantization scale:
         # input_scale * weight_scale. To avoid hidden numerics error, we check
@@ -495,7 +517,13 @@ def materialize_fc_conv(
     weights, bias).
   """
   ignored_inputs = [bias_index]  # Bias tensor is quantized separately.
-  if _are_weights_too_small(op_info, graph_info, weight_index):
+  should_ignore_weight = False
+  if graph_info:
+    w_tensor = graph_info.subgraph_tensors[op_info.op.inputs[weight_index]]
+    should_ignore_weight = check_if_quantized(w_tensor)
+  if should_ignore_weight or _are_weights_too_small(
+      op_info, graph_info, weight_index
+  ):
     ignored_inputs.append(weight_index)
 
   op_tensor_params = common_utils.materialize_standard_op(
@@ -506,7 +534,7 @@ def materialize_fc_conv(
       inputs_to_ignore=ignored_inputs,
   )
 
-  _materialize_bias_for_conv_ops(
+  _materialize_bias_for_fc_conv_ops(
       op_info,
       graph_info,
       op_tensor_params,
@@ -561,7 +589,7 @@ def materialize_conv2d_transpose(
         "Materialize standard op should return at least two tensors for"
         " conv2d_transpose."
     )
-  _materialize_bias_for_conv_ops(
+  _materialize_bias_for_fc_conv_ops(
       op_info,
       graph_info,
       op_tensor_params,

ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize.py

@@ -108,6 +108,13 @@ def get_tensor_quant_params(
   return dataclasses.replace(quant_params, quantized_data=quantized_vars)
 
 
+def check_if_quantized(tensor: Any) -> bool:
+  """Checks if the tensor is quantized."""
+  return (
+      tensor.quantization is not None and tensor.quantization.scale is not None
+  )
+
+
 # TODO: b/333731147 - Use named tuple to store min/max.
 def init_qsvs(
     op_info: qtyping.OpInfo,
@@ -129,6 +136,13 @@ def init_qsvs(
   op_qsvs = {}
 
   inputs_to_ignore = inputs_to_ignore or []
+  quantized_inputs_to_ignore = [
+      opr_idx
+      for opr_idx, tensor_idx in enumerate(op_info.op.inputs)
+      if check_if_quantized(graph_info.subgraph_tensors[tensor_idx])
+  ]
+  inputs_to_ignore.extend(quantized_inputs_to_ignore)
+
   outputs_to_ignore = outputs_to_ignore or []
   for opr_idx, tensor_idx in enumerate(op_info.op.inputs):
     if tensor_idx != -1 and opr_idx not in inputs_to_ignore:
@@ -207,6 +221,12 @@ def min_max_calibrate(
     }
 
   inputs_to_ignore = inputs_to_ignore or []
+  quantized_inputs_to_ignore = [
+      opr_idx
+      for opr_idx, tensor_idx in enumerate(tfl_op.inputs)
+      if check_if_quantized(graph_info.subgraph_tensors[tensor_idx])
+  ]
+  inputs_to_ignore.extend(quantized_inputs_to_ignore)
   outputs_to_ignore = outputs_to_ignore or []
   for i, tensor_idx in enumerate(tfl_op.inputs):
     if tensor_idx != -1 and i not in inputs_to_ignore:

ai_edge_quantizer/calibrator.py

@@ -46,11 +46,6 @@ class Calibrator:
   ):
     self._flatbuffer_model = tfl_flatbuffer_utils.read_model(float_tflite)
 
-    if not tfl_flatbuffer_utils.is_float_model(self._flatbuffer_model):
-      raise ValueError(
-          "The input model for calibration is not a float model. Please check"
-          " the model (e.g., if it is already quantized)."
-      )
     self._tfl_interpreter = tfl_interpreter_utils.create_tfl_interpreter(
         float_tflite, use_xnnpack=True, num_threads=num_threads
     )

ai_edge_quantizer/calibrator_test.py

@@ -184,15 +184,11 @@ class CalibratorAlreadyQuantizedModelTest(googletest.TestCase):
     )
     _ = calibrator.Calibrator(test_model_path)
 
-  def test_check_is_float_model_raises_error_when_model_is_quantized(self):
+  def test_check_is_quantized_model_succeeds_when_model_is_quantized(self):
     test_model_path = os.path.join(
         TEST_DATA_PREFIX_PATH, "tests/models/mnist_quantized.tflite"
     )
-    with self.assertRaisesRegex(
-        ValueError,
-        "The input model for calibration is not a float model.",
-    ):
-      _ = calibrator.Calibrator(test_model_path)
+    _ = calibrator.Calibrator(test_model_path)
 
 
 class CalibratorToyGemma2Test(googletest.TestCase):

ai_edge_quantizer/model_validator.py

@@ -118,7 +118,8 @@ class ComparisonResult:
     for name in utils.get_input_tensor_names(
         self._reference_model, signature_key
     ):
-      input_tensor_results[name] = result.pop(name)
+      if name in result:
+        input_tensor_results[name] = result.pop(name)
 
     output_tensor_results = {}
     for name in utils.get_output_tensor_names(
@@ -136,7 +137,8 @@ class ComparisonResult:
         self._reference_model,
         subgraph_index,
     ):
-      constant_tensor_results[name] = result.pop(name)
+      if name in result:
+        constant_tensor_results[name] = result.pop(name)
 
     self._comparison_results[signature_key] = SingleSignatureComparisonResult(
         error_metric=error_metric,
@@ -214,6 +216,7 @@ def _setup_validation_interpreter(
     signature_key: Optional[str],
     use_xnnpack: bool,
     num_threads: int,
+    preserve_all_tensors: bool = True,
 ) -> tuple[Any, int, dict[str, Any]]:
   """Setup the interpreter for validation given a signature key.
 
@@ -224,13 +227,17 @@ def _setup_validation_interpreter(
       model only has one signature, this can be set to None.
     use_xnnpack: Whether to use xnnpack for the interpreter.
     num_threads: The number of threads to use for the interpreter.
+    preserve_all_tensors: Whether to preserve all tensors.
 
   Returns:
     A tuple of interpreter, subgraph_index and tensor_name_to_details.
   """
 
   interpreter = utils.create_tfl_interpreter(
-      tflite_model=model, use_xnnpack=use_xnnpack, num_threads=num_threads
+      tflite_model=model,
+      use_xnnpack=use_xnnpack,
+      num_threads=num_threads,
+      preserve_all_tensors=preserve_all_tensors,
   )
   utils.invoke_interpreter_signature(
       interpreter, signature_input, signature_key
@@ -255,6 +262,7 @@ def compare_model(
     compare_fn: Callable[[Any, Any], float],
     use_xnnpack: bool = True,
     num_threads: int = 16,
+    validate_output_tensors_only: bool = False,
 ) -> ComparisonResult:
   """Compares model tensors over a model signature using the compare_fn.
 
@@ -275,10 +283,13 @@ def compare_model(
       single float value.
     use_xnnpack: Whether to use xnnpack for the interpreter.
     num_threads: The number of threads to use for the interpreter.
+    validate_output_tensors_only: If True, only compare output tensors.
+      Otherwise, compare all tensors.
 
   Returns:
     A ComparisonResult object.
   """
+  preserve_all_tensors = not validate_output_tensors_only
   model_comparion_result = ComparisonResult(reference_model, target_model)
   for signature_key, signature_inputs in test_data.items():
     comparison_results = {}
@@ -291,6 +302,7 @@ def compare_model(
               signature_key,
               use_xnnpack,
               num_threads,
+              preserve_all_tensors=preserve_all_tensors,
           )
       )
       targ_interpreter, targ_subgraph_index, targ_tensor_name_to_details = (
@@ -300,10 +312,18 @@ def compare_model(
               signature_key,
               use_xnnpack,
               num_threads,
+              preserve_all_tensors=preserve_all_tensors,
           )
       )
-      # Compare the cached tensor values.
-      for tensor_name, detail in ref_tensor_name_to_details.items():
+      # Compare the cached tensor value
+      tensor_names_to_compare = (
+          utils.get_output_tensor_names(reference_model, signature_key)
+          if validate_output_tensors_only
+          else list(ref_tensor_name_to_details.keys())
+      )
+
+      for tensor_name in tensor_names_to_compare:
+        detail = ref_tensor_name_to_details[tensor_name]
         if detail['dtype'] == np.object_:
           continue
         # Ignore tensors where any dimension of the shape is 0.

ai_edge_quantizer/params_generator.py

@@ -35,12 +35,12 @@ class ParamsGenerator:
   def __init__(self, float_tflite: Union[str, bytes]):
     self.flatbuffer_model = tfl_flatbuffer_utils.read_model(float_tflite)
 
-    if not tfl_flatbuffer_utils.is_float_model(self.flatbuffer_model):
-      raise ValueError(
-          'The input model for quantization parameters generation is not a'
-          ' float model. Please check the model (e.g., if it is already'
-          ' quantized).'
-      )
+    # if not tfl_flatbuffer_utils.is_float_model(self.flatbuffer_model):
+    #   raise ValueError(
+    #       'The input model for quantization parameters generation is not a'
+    #       ' float model. Please check the model (e.g., if it is already'
+    #       ' quantized).'
+    #   )
     self._check_tensor_names_are_unique()
     self.buffer_to_tensors: dict[int, list[Any]] = (
         tfl_flatbuffer_utils.buffer_to_tensors(self.flatbuffer_model)
@@ -409,7 +409,11 @@ class ParamsGenerator:
     buffers_to_duplicate = []
     tensor_names_to_duplicate = []
     for buffer_idx, tensors in self.buffer_to_tensors.items():
-      if not tensors:
+      # TODO: b/458797890 - Investigate if skipping buffer_idx == 0 is a
+      # correct fix, or if it just covers up a deeper issue. This is only
+      # required when statically quantizing models that have already been
+      # quantized dynamically.
+      if not tensors or buffer_idx == 0:
         continue
       # Check if any of the tensors needs to be duplicated.
       for tensor in tensors:

ai_edge_quantizer/params_generator_test.py

@@ -1135,16 +1135,11 @@ class ParamsGeneratorAlreadyQuantizedModelTest(googletest.TestCase):
     )
     _ = params_generator.ParamsGenerator(test_model_path)
 
-  def test_check_is_float_model_raises_error_when_model_is_quantized(self):
+  def test_check_is_quantized_model_succeeds_when_model_is_quantized(self):
     test_model_path = os.path.join(
         TEST_DATA_PREFIX_PATH, 'tests/models/mnist_quantized.tflite'
     )
-    with self.assertRaisesRegex(
-        ValueError,
-        'The input model for quantization parameters generation is not a float'
-        ' model.',
-    ):
-      _ = params_generator.ParamsGenerator(test_model_path)
+    _ = params_generator.ParamsGenerator(test_model_path)
 
 
 if __name__ == '__main__':

ai_edge_quantizer/quantizer.py

@@ -434,6 +434,7 @@ class Quantizer:
       error_metrics: str = 'mse',
       use_xnnpack: bool = True,
       num_threads: int = 16,
+      validate_output_tensors_only: bool = False,
   ) -> model_validator.ComparisonResult:
     """Numerical validation of the quantized model for a model signature.
 
@@ -452,6 +453,8 @@ class Quantizer:
       error_metrics: Error metrics to be used for comparison.
       use_xnnpack: Whether to use the xnnpack library for validation.
       num_threads: Number of threads to use for validation.
+      validate_output_tensors_only: If True, only compare output tensors.
+        Otherwise, compare all tensors.
 
     Returns:
       The comparison result.
@@ -476,6 +479,7 @@ class Quantizer:
         validation_utils.get_validation_func(error_metrics),
         use_xnnpack=use_xnnpack,
         num_threads=num_threads,
+        validate_output_tensors_only=validate_output_tensors_only,
     )
 
   def _get_quantization_params(

ai_edge_quantizer/quantizer_test.py

@@ -375,6 +375,19 @@ class QuantizerTest(parameterized.TestCase):
         'sequential/dense_1/MatMul', validation_result.intermediate_tensors
     )
 
+  def test_validate_output_tensors_only_succeeds(self):
+    self._quantizer.quantize()
+    validation_result = self._quantizer.validate(
+        validate_output_tensors_only=True
+    )
+    validation_result = validation_result.get_signature_comparison_result()
+    self.assertIsNotNone(validation_result)
+    self.assertEmpty(validation_result.input_tensors)
+    self.assertEmpty(validation_result.constant_tensors)
+    self.assertEmpty(validation_result.intermediate_tensors)
+    self.assertNotEmpty(validation_result.output_tensors)
+    self.assertIn('StatefulPartitionedCall:0', validation_result.output_tensors)
+
   def test_validate_with_quantized_model_arg_succeeds(self):
     self._quantizer.quantize()
     quantized_model = self._quantizer._result.quantized_model
@@ -431,6 +444,33 @@ class QuantizerTest(parameterized.TestCase):
         op_config=test_op_config,
     )
 
+  def test_two_pass_quantization_with_conv_and_fc_succeeds(self):
+    float_model_path = self._test_model_path
+
+    drq_recipe_path = os.path.join(
+        TEST_DATA_PREFIX_PATH, 'recipes/dynamic_wi8_afp32_hadamard_recipe.json'
+    )
+    drq_quantizer = quantizer.Quantizer(float_model_path)
+    drq_quantizer.load_quantization_recipe(drq_recipe_path)
+    drq_result = drq_quantizer.quantize()
+    drq_model_path = os.path.join(self._tmp_save_path, 'drq_model.tflite')
+    drq_result.export_model(drq_model_path)
+
+    srq_recipe_path = os.path.join(
+        TEST_DATA_PREFIX_PATH, 'recipes/default_a8w8_recipe.json'
+    )
+    srq_quantizer = quantizer.Quantizer(drq_model_path)
+    srq_quantizer.load_quantization_recipe(srq_recipe_path)
+    representative_dataset = (
+        tfl_interpreter_utils.create_random_normal_input_data(
+            drq_model_path, num_samples=1
+        )
+    )
+    calibration_result = srq_quantizer.calibrate(representative_dataset)
+    srq_result = srq_quantizer.quantize(calibration_result)
+    srq_model_path = os.path.join(self._tmp_save_path, 'srq_model.tflite')
+    srq_result.export_model(srq_model_path)
+
 
 class QuantizerBytearrayInputs(googletest.TestCase):
 

ai_edge_quantizer/transformation_instruction_generator.py

@@ -54,6 +54,15 @@ def check_horizontal_optimization(
   Returns:
     True if the two transformations can be merged, False otherwise
   """
+  if (
+      isinstance(param1.parameters, qtyping.UniformQuantParams)
+      and param1.parameters.hadamard is not None
+  ):
+    if (
+        isinstance(param2.parameters, qtyping.UniformQuantParams)
+        and param2.parameters.hadamard is not None
+    ):
+      return True
   return (
       param1.parameters == param2.parameters
       and len(param1.transformations) > index

ai_edge_quantizer/utils/constrained_ops_utils.py

@@ -60,22 +60,22 @@ def get_constrained_op_list(
   def are_weights_too_small_wrapper(*_args, **_kwargs) -> bool:
     return False
 
-  # Dummy implementation of the `_materialize_bias_for_conv_ops` function to
+  # Dummy implementation of the `_materialize_bias_for_fc_conv_ops` function to
   # support `materialize_standard_op_wrapper` above.
-  def materialize_bias_for_conv_ops_wrapper(*_args, **_kwargs):
+  def materialize_bias_for_fc_conv_ops_wrapper(*_args, **_kwargs):
     return
 
   # Do monkey patch to intercept the `materialize_standard_op` function to
   # support `materialize_standard_op_wrapper` above.
   original_materialize_standard_op = common_utils.materialize_standard_op
   original_are_weights_too_small = common_quantize._are_weights_too_small  # pylint: disable=protected-access
-  original_materialize_bias_for_conv_ops = (
-      common_quantize._materialize_bias_for_conv_ops  # pylint: disable=protected-access
+  original_materialize_bias_for_fc_conv_ops = (
+      common_quantize._materialize_bias_for_fc_conv_ops  # pylint: disable=protected-access
   )
   common_utils.materialize_standard_op = materialize_standard_op_wrapper
   common_quantize._are_weights_too_small = are_weights_too_small_wrapper  # pylint: disable=protected-access
-  common_quantize._materialize_bias_for_conv_ops = (  # pylint: disable=protected-access
-      materialize_bias_for_conv_ops_wrapper
+  common_quantize._materialize_bias_for_fc_conv_ops = (  # pylint: disable=protected-access
+      materialize_bias_for_fc_conv_ops_wrapper
   )
   minmax_func_dict = algorithm_manager.MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT
 
@@ -105,7 +105,7 @@ def get_constrained_op_list(
   # Restore the original functions.
   common_utils.materialize_standard_op = original_materialize_standard_op
   common_quantize._are_weights_too_small = original_are_weights_too_small  # pylint: disable=protected-access
-  common_quantize._materialize_bias_for_conv_ops = (  # pylint: disable=protected-access
-      original_materialize_bias_for_conv_ops
+  common_quantize._materialize_bias_for_fc_conv_ops = (  # pylint: disable=protected-access
+      original_materialize_bias_for_fc_conv_ops
   )
   return constrained_ops

ai_edge_quantizer/utils/tfl_interpreter_utils.py

@@ -35,6 +35,7 @@ def create_tfl_interpreter(
     allocate_tensors: bool = True,
     use_xnnpack: bool = True,
     num_threads: int = 16,
+    preserve_all_tensors: bool = True,
 ) -> tfl.Interpreter:
   """Creates a TFLite interpreter from a model file.
 
@@ -43,6 +44,8 @@ def create_tfl_interpreter(
     allocate_tensors: Whether to allocate tensors.
     use_xnnpack: Whether to use the XNNPACK delegate for the interpreter.
     num_threads: The number of threads to use for the interpreter.
+    preserve_all_tensors: Whether to preserve all tensors. If False, only input
+      and output tensors are preserved.
 
   Returns:
     A TFLite interpreter.
@@ -59,7 +62,7 @@ def create_tfl_interpreter(
       model_content=bytes(tflite_model),
       num_threads=num_threads,
       experimental_op_resolver_type=op_resolver,
-      experimental_preserve_all_tensors=True,
+      experimental_preserve_all_tensors=preserve_all_tensors,
   )
   if allocate_tensors:
     tflite_interpreter.allocate_tensors()

ai_edge_quantizer/utils/tfl_interpreter_utils_test.py

@@ -90,6 +90,16 @@ class TflUtilsSingleSignatureModelTest(googletest.TestCase):
     ]
     self.assertEqual(tuple(average_pool_res.shape), (1, 14, 14, 8))
 
+  def test_get_tensor_name_to_content_map_fails_no_preserve_all_tensors(self):
+    tfl_interpreter = tfl_interpreter_utils.create_tfl_interpreter(
+        self._test_model_path, preserve_all_tensors=False
+    )
+    tfl_interpreter_utils.invoke_interpreter_once(
+        tfl_interpreter, [self._input_data]
+    )
+    with self.assertRaisesRegex(ValueError, "Tensor data is null."):
+      tfl_interpreter_utils.get_tensor_name_to_content_map(tfl_interpreter)
+
   def test_is_tensor_quantized(self):
     tfl_interpreter = tfl_interpreter_utils.create_tfl_interpreter(
         self._test_model_path

{ai_edge_quantizer_nightly-0.5.0.dev20251209.dist-info → ai_edge_quantizer_nightly-0.5.0.dev20251211.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-edge-quantizer-nightly
-Version: 0.5.0.dev20251209
+Version: 0.5.0.dev20251211
 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.5.0.dev20251209.dist-info → ai_edge_quantizer_nightly-0.5.0.dev20251211.dist-info}/RECORD

@@ -2,24 +2,24 @@ ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas
 ai_edge_quantizer/algorithm_manager.py,sha256=0jSNITKl0Ge1XeYKueOUj9brlS4B5ZcdcVQ1kZS3JKg,16518
 ai_edge_quantizer/algorithm_manager_api.py,sha256=u903TG0s1uIDhJqfeJne3CFl8A93phZrwgV2-hwdcXU,9247
 ai_edge_quantizer/algorithm_manager_api_test.py,sha256=w6bSONvXkX6bzXAGc0-7b6gNDt9oz9ieq97KP8Sg_JU,7666
-ai_edge_quantizer/calibrator.py,sha256=brB6ENjZFQnIzlshr0zAFo0g-XjwvD-Wsy5VasJspRU,9986
-ai_edge_quantizer/calibrator_test.py,sha256=VKK6p9M3EwSq4D7Sna2v1EFeop2zfL-Af-YiusIuyb8,8957
+ai_edge_quantizer/calibrator.py,sha256=nkHUmxdWy16Vw3EOD3B_7EkGiX8V-XJRXXFynweGfG8,9744
+ai_edge_quantizer/calibrator_test.py,sha256=c2ZCjl7PQYU9KtAovpDO9JX8sClgaLGO0P7oqoL6rP0,8830
 ai_edge_quantizer/conftest.py,sha256=SxCz-5LlRD_lQm4hQc4c6IGG7DS8d7IyEWY9gnscPN0,794
 ai_edge_quantizer/default_policy.py,sha256=YcwwtVzoWUhjYgMtJ7b9f647740lURKteDOeJvwe17o,11384
 ai_edge_quantizer/model_modifier.py,sha256=U70JByv6CItP8tg4bdyMfX-R3UlwylAGSviZkF_FSAM,10468
 ai_edge_quantizer/model_modifier_test.py,sha256=CV4pgMEQkBJr_qbYR720TO8HBCutbEYLHptDHgdQMUE,7274
-ai_edge_quantizer/model_validator.py,sha256=Hj0_5o-Oa3dSlJ3ryVjRhvsyelHNyek1GrtG9buMczg,13153
+ai_edge_quantizer/model_validator.py,sha256=HCXl8lu8wRmLn6wUaEm3I7xDOul3s7VC6XzbKjGfkuU,13945
 ai_edge_quantizer/model_validator_test.py,sha256=EeqOP_mrZsnZ3rug756s0ryDDqd2KgIDld5Lm_gDuWY,13020
-ai_edge_quantizer/params_generator.py,sha256=0w-sDGk84sVNkXoduon1wDqq30sGOHVgBVbdg44QVF4,20153
-ai_edge_quantizer/params_generator_test.py,sha256=RDYoRZDJfEZRtjlTAU2kZ_4t3JHOqEHxfJX9V4ETAhg,40597
+ai_edge_quantizer/params_generator.py,sha256=-tbXB6crutiFhmLFEMe_-sxGylsvgd_cRZQ2fB67bNE,20436
+ai_edge_quantizer/params_generator_test.py,sha256=gJlq_qCPC0dWkbkyCpQiqAsmCYoWYxtxM2xYMEkrr3g,40436
 ai_edge_quantizer/qtyping.py,sha256=y9KretGzUGztyLdmto2XV6U0cxrSrfLWP1UOVcwR4dY,18011
-ai_edge_quantizer/quantizer.py,sha256=teYeONdIS31IAY6ubLujCRi1t6lYAd0LkC8dRPxQdbw,18919
-ai_edge_quantizer/quantizer_test.py,sha256=pavS0mezRdBAGD4lqBUhj53pXJDFH3U02ldxxh5RDYQ,28407
+ai_edge_quantizer/quantizer.py,sha256=_XRzj1UTXoPa0AeE1Ygz6XAelst2p2fGLqrhYB5MOCg,19150
+ai_edge_quantizer/quantizer_test.py,sha256=6gcOLsZO-XW9VoKmcf_9CalG-_2lSUAe_fcmH2zHcoU,30167
 ai_edge_quantizer/recipe.py,sha256=MEkfQ2Sg3KAE9LAORHWcbjYNPg06EUbwc1d-VspQA2U,6461
 ai_edge_quantizer/recipe_manager.py,sha256=6l2uq8KL23KLu9OQDmPGkxrFiwHrdDB9xnn-ni8WdEM,15036
 ai_edge_quantizer/recipe_manager_test.py,sha256=gYK3haUJ8-AISQvTI6tD-E-drJXQPSXPqBZdgpc5QTo,36595
 ai_edge_quantizer/recipe_test.py,sha256=QisyaTol8JRZFcGOGyee7QRCvqj5VbF4guKWdIoMUOE,6213
-ai_edge_quantizer/transformation_instruction_generator.py,sha256=O0U2aZcB8aXQgOV8r9g1rGNzDUiuI5Ta53XnxZbVffE,31576
+ai_edge_quantizer/transformation_instruction_generator.py,sha256=YmjtOFqc4ajGzvHEWTyIUIom0I0uJtxt4Uc9nxzmw2A,31852
 ai_edge_quantizer/transformation_instruction_generator_test.py,sha256=KW5-WoTTo9IqLEVnWxVC8ut8eWLi_91xfKgGqVQ9QDk,54635
 ai_edge_quantizer/transformation_performer.py,sha256=mFsig0E5Isy7cnG1wMO2jzBn3Wql8fElM_PSpaL8okw,13354
 ai_edge_quantizer/transformation_performer_test.py,sha256=xk6A3LStCyPclN51--9uO7XjSxNfZmpdfvrzOL0maNM,20349
@@ -28,7 +28,7 @@ ai_edge_quantizer/algorithms/nonlinear_quantize/__init__.py,sha256=lpq1g2ayg3lCP
 ai_edge_quantizer/algorithms/nonlinear_quantize/float_casting.py,sha256=Bs9CK7wZAw6jNaZ8xEtbwO2vM34VYXNZSMVWvxJo9nw,9297
 ai_edge_quantizer/algorithms/nonlinear_quantize/float_casting_test.py,sha256=EqIHGEZ1LgUrTN7zf880RuAzEv3Qy7kgh5ivObJGHSo,22646
 ai_edge_quantizer/algorithms/uniform_quantize/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=wrp4F2Wo9ammz_6VXFjXu04RMJV4_MxGfp4XyFMhZHc,39904
+ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=s4JudZaYZlL5PwdfjKV-HcbaVSzVcXXueNFdBxZDv9I,41033
 ai_edge_quantizer/algorithms/uniform_quantize/common_quantize_test.py,sha256=GGf_n3wIeg3GB_eGsmyNJ0fTcxgpeMMbugTMRONK6TQ,3553
 ai_edge_quantizer/algorithms/uniform_quantize/dequantized_weight_recovery.py,sha256=VjBDxGxjITHJc7xJABqBbZt6_qhobtZAl2gnVQrYJgc,8652
 ai_edge_quantizer/algorithms/uniform_quantize/dequantized_weight_recovery_test.py,sha256=sT5eX5TLZEHTtPfnSkCPDlS0sQxlTFWbCsbvOuj--yY,8889
@@ -36,7 +36,7 @@ ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation.py,sha256=qxt9CP
 ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation_test.py,sha256=1ejj5WS3GZwFk3qpsPiPS8jcmVS1-e7zRmvj2Nj8fKw,15440
 ai_edge_quantizer/algorithms/uniform_quantize/mse.py,sha256=EP5yPw6khAhTo6VNTPXEE2aGKLfNnqz8COeJnTKaGWs,4641
 ai_edge_quantizer/algorithms/uniform_quantize/mse_test.py,sha256=-E1LIlxadckspltdgBWTiUzsiwbawSubndavHhWLt1g,7145
-ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize.py,sha256=3HldmkAZv1EN0GeUWr574L9brknb569KB8i1iIGgcx0,8334
+ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize.py,sha256=NCLKwM8Teu2yI-Qd36e8KfqZWIqtHeAg_gMD7Z_sqNE,8988
 ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize_test.py,sha256=Eqa4OUqoCGywbHz-HxJ9dWRj9BKlVzJPuIhVzvrpdLM,8925
 ai_edge_quantizer/algorithms/uniform_quantize/octav.py,sha256=-n-QZyp9y8WCy5FPSpXZXHfOA-p-RLvfSaCzAfhHiHI,7040
 ai_edge_quantizer/algorithms/uniform_quantize/octav_test.py,sha256=6m2U-9JdNei0XzOORg2gt87TJdD0XHZ-z5h9c4g_TB4,9120
@@ -65,17 +65,17 @@ ai_edge_quantizer/transformations/transformation_utils_test.py,sha256=MWgq29t7rv
 ai_edge_quantizer/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
 ai_edge_quantizer/utils/calibration_utils.py,sha256=iMf_bSCf-O86MzDt5D9hLKqbTydqLwirluaC6BJ9yHo,11553
 ai_edge_quantizer/utils/calibration_utils_test.py,sha256=4BlksXl7b4yptL8xPR67hmJCnjhN9V10a2PunzfHrUE,9372
-ai_edge_quantizer/utils/constrained_ops_utils.py,sha256=EAITCf7Ku_PFZcw3K-wd-8hGbyuRd5W5UtNdGvalwAE,4478
+ai_edge_quantizer/utils/constrained_ops_utils.py,sha256=z0sm1R9anRRVgdgI23XQKwDRcdARdpTo_6UBDB_lHXE,4502
 ai_edge_quantizer/utils/constrained_ops_utils_test.py,sha256=i_uERo-KvMj0dvUSuI67kdOBHvRQETg8-qnejs_MgTE,1756
 ai_edge_quantizer/utils/test_utils.py,sha256=a4Nk-wbeB09dFjTDZiA0K67d26j5DD0UDH_GIVmVG_4,8685
 ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=42OWzQsRTXq3XQYmoxlz177_dw2fJfq7mDSJaU--ArQ,12076
 ai_edge_quantizer/utils/tfl_flatbuffer_utils_test.py,sha256=K1SbK8q92qYVtiVj0I0GtugsPTkpIpEKv9zakvFV_Sc,8555
-ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=EoVjI_hplX_Rml3hfRsGmQOihexmizeJqt4SQcET9aA,14925
-ai_edge_quantizer/utils/tfl_interpreter_utils_test.py,sha256=6fjkM-rycZ95L4yfvlr0TN6RlrhfPzxNUYrZaYO_F0A,12013
+ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=zgXVSIoNU-M2V1Wcq06M0MPoA-dCXXEZd1Y9vvors_c,15100
+ai_edge_quantizer/utils/tfl_interpreter_utils_test.py,sha256=EPOXbmXqbt3tAewo3BQQjh2mjuxrrFit5tkF0wUVYHU,12471
 ai_edge_quantizer/utils/validation_utils.py,sha256=Mr0D6X-pTDLODFAnCX3IlqdV1OL02tlq0ZjHbqx8nzg,7439
 ai_edge_quantizer/utils/validation_utils_test.py,sha256=T8K5mCWeMcihND2KS_dHvCJUU9lEdG2sD95EgPkaX3w,5584
-ai_edge_quantizer_nightly-0.5.0.dev20251209.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.5.0.dev20251209.dist-info/METADATA,sha256=CAwWjjC0V1-vTAm_27d62tjLJG5q6KJWffVqpGqdy7g,1707
-ai_edge_quantizer_nightly-0.5.0.dev20251209.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-ai_edge_quantizer_nightly-0.5.0.dev20251209.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.5.0.dev20251209.dist-info/RECORD,,
+ai_edge_quantizer_nightly-0.5.0.dev20251211.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.5.0.dev20251211.dist-info/METADATA,sha256=lvKdgf6OsKuQ_r5s7ZV8Zdj64RJxlwux0Eiyo0Ao0KI,1707
+ai_edge_quantizer_nightly-0.5.0.dev20251211.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+ai_edge_quantizer_nightly-0.5.0.dev20251211.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.5.0.dev20251211.dist-info/RECORD,,