ai-edge-quantizer-nightly 0.5.0.dev20251130__py3-none-any.whl → 0.5.0.dev20260112__py3-none-any.whl

ai_edge_quantizer/algorithm_manager.py

@@ -118,6 +118,9 @@ MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT = {
     ),
     _TFLOpName.MAX_POOL_2D: common_quantize.materialize_max_pool_2d,
     _TFLOpName.RESIZE_BILINEAR: common_quantize.materialize_resize_bilinear,
+    _TFLOpName.RESIZE_NEAREST_NEIGHBOR: (
+        common_quantize.materialize_resize_nearest_neighbor
+    ),
     _TFLOpName.GATHER_ND: common_quantize.materialize_gather_nd,
     _TFLOpName.PACK: common_quantize.materialize_pack,
     _TFLOpName.UNPACK: common_quantize.materialize_unpack,
@@ -133,6 +136,7 @@ MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT = {
     _TFLOpName.NOT_EQUAL: common_quantize.materialize_not_equal,
     _TFLOpName.MIRROR_PAD: common_quantize.materialize_mirror_pad,
     _TFLOpName.SPACE_TO_DEPTH: common_quantize.materialize_space_to_depth,
+    _TFLOpName.RELU: common_quantize.materialize_relu,
 }
 for op_name, materialize_func in MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT.items():
   register_quantized_op(
@@ -273,6 +277,9 @@ _OCTAV_OP_NAME_MATERIALIZE_FUNC_DICT = immutabledict({
     ),
     _TFLOpName.MAX_POOL_2D: common_quantize.materialize_max_pool_2d,
     _TFLOpName.RESIZE_BILINEAR: common_quantize.materialize_resize_bilinear,
+    _TFLOpName.RESIZE_NEAREST_NEIGHBOR: (
+        common_quantize.materialize_resize_nearest_neighbor
+    ),
     _TFLOpName.GATHER_ND: common_quantize.materialize_gather_nd,
     _TFLOpName.PACK: common_quantize.materialize_pack,
     _TFLOpName.UNPACK: common_quantize.materialize_unpack,
@@ -288,6 +295,7 @@ _OCTAV_OP_NAME_MATERIALIZE_FUNC_DICT = immutabledict({
     _TFLOpName.NOT_EQUAL: common_quantize.materialize_not_equal,
     _TFLOpName.MIRROR_PAD: common_quantize.materialize_mirror_pad,
     _TFLOpName.SPACE_TO_DEPTH: common_quantize.materialize_space_to_depth,
+    _TFLOpName.RELU: common_quantize.materialize_relu,
 })
 
 for op_name, materialize_func in _OCTAV_OP_NAME_MATERIALIZE_FUNC_DICT.items():

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
@@ -324,6 +346,7 @@ def _materialize_bias_for_conv_ops(
                 bias_content,
                 input_consumer_params,
                 weight_consumer_params,
+                not op_info.op_quant_config.skip_checks,
             )
         )
       except ValueError as e:
@@ -495,7 +518,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 +535,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 +590,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,
@@ -851,6 +880,23 @@ def materialize_resize_bilinear(
   )
 
 
+def materialize_resize_nearest_neighbor(
+    get_tensor_quant_params_fn: qtyping.GetTensorQuantParamsFuncSignature,
+    op_info: qtyping.OpInfo,
+    graph_info: qtyping.GraphInfo,
+    tensor_name_to_qsv: dict[str, Any],
+) -> list[qtyping.TensorTransformationParams]:
+  """Materialize tensors in tfl.resize_nearest_neighbor."""
+  return common_utils.materialize_standard_op(
+      op_info,
+      graph_info,
+      tensor_name_to_qsv,
+      get_tensor_quant_params_fn,
+      constraint=_OpQuantConstraint.SAME_AS_INPUT_SCALE,
+      inputs_to_ignore=[1],  # Resize size does not need to be quantized.
+  )
+
+
 def materialize_gather_nd(
     get_tensor_quant_params_fn: qtyping.GetTensorQuantParamsFuncSignature,
     op_info: qtyping.OpInfo,
@@ -1042,6 +1088,21 @@ def materialize_not_equal(
   )
 
 
+def materialize_relu(
+    get_tensor_quant_params_fn: qtyping.GetTensorQuantParamsFuncSignature,
+    op_info: qtyping.OpInfo,
+    graph_info: qtyping.GraphInfo,
+    tensor_name_to_qsv: dict[str, Any],
+) -> list[qtyping.TensorTransformationParams]:
+  """Materialize tensors in tfl.relu."""
+  return common_utils.materialize_standard_op(
+      op_info,
+      graph_info,
+      tensor_name_to_qsv,
+      get_tensor_quant_params_fn,
+  )
+
+
 def _get_tensor_shape_for_blockwise(
     tensor_shape: Sequence[int], quantized_dim: int, block_size: int
 ) -> list[int]:

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/algorithms/uniform_quantize/uniform_quantize_tensor_test.py

@@ -414,7 +414,10 @@ class TensorUtilsTest(parameterized.TestCase):
         list(bias_quant_config.quantized_data.flatten()),  # pytype: disable=attribute-error
     )
 
-  def test_quantize_bias_tensor_raises_error_for_large_quantization_error(self):
+  @parameterized.parameters(True, False)
+  def test_quantize_bias_tensor_raises_error_for_large_quantization_error(
+      self, check_error
+  ):
     input_quant_config = qtyping.UniformQuantParams(
         scale=np.array([0.1]),
         zero_point=np.array([10]),
@@ -431,14 +434,26 @@ class TensorUtilsTest(parameterized.TestCase):
     )
     # This will result in quantized bias of 3e9, which is larger than int32 max.
     bias_tensor_data = np.array([3e7])
-    with self.assertRaisesRegex(
-        ValueError,
-        "Quantization error is too large for bias tensor quantization.",
-    ):
-      uniform_quantize_tensor.symmetric_quantize_bias_tensor(
-          bias_tensor_data,
-          input_quant_config,
-          weight_quant_config,
+
+    if check_error:
+      with self.assertRaisesRegex(
+          ValueError,
+          "Quantization error is too large for bias tensor quantization.",
+      ):
+        uniform_quantize_tensor.symmetric_quantize_bias_tensor(
+            bias_tensor_data,
+            input_quant_config,
+            weight_quant_config,
+            check_error
+        )
+    else:
+      self.assertIsNotNone(
+          uniform_quantize_tensor.symmetric_quantize_bias_tensor(
+              bias_tensor_data,
+              input_quant_config,
+              weight_quant_config,
+              check_error,
+          )
       )
 
   @parameterized.parameters((8, True), (16, False))

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/default_policy.py

@@ -19,9 +19,9 @@ import collections
 import copy
 import json
 from typing import Any, Union
+from ai_edge_litert.tools import flatbuffer_utils
 from ai_edge_quantizer import qtyping
 from ai_edge_litert import schema_py_generated as schema  # pylint:disable=g-direct-tensorflow-import
-from tensorflow.lite.tools import flatbuffer_utils  # pylint: disable=g-direct-tensorflow-import
 
 _TFLOpName = qtyping.TFLOperationName
 _OpQuantizationConfig = qtyping.OpQuantizationConfig
@@ -186,6 +186,7 @@ DEFAULT_JSON_POLICY = """
       "PAD",
       "MAX_POOL_2D",
       "RESIZE_BILINEAR",
+      "RESIZE_NEAREST_NEIGHBOR",
       "GATHER_ND",
       "PACK",
       "UNPACK",
@@ -198,7 +199,8 @@ DEFAULT_JSON_POLICY = """
       "REDUCE_MIN",
       "EQUAL",
       "NOT_EQUAL",
-      "MIRROR_PAD"
+      "MIRROR_PAD",
+      "RELU"
     ],
     "static_wi8_ai8": [
       "ADD",
@@ -234,6 +236,7 @@ DEFAULT_JSON_POLICY = """
       "SQUARED_DIFFERENCE",
       "MAX_POOL_2D",
       "RESIZE_BILINEAR",
+      "RESIZE_NEAREST_NEIGHBOR",
       "GATHER_ND",
       "PACK",
       "UNPACK",
@@ -248,7 +251,8 @@ DEFAULT_JSON_POLICY = """
       "EQUAL",
       "NOT_EQUAL",
       "MIRROR_PAD",
-      "SPACE_TO_DEPTH"
+      "SPACE_TO_DEPTH",
+      "RELU"
     ],
     "static_wi4_ai8": ["FULLY_CONNECTED", "CONV_2D", "INPUT", "OUTPUT"],
     "static_wi4_ai16": ["FULLY_CONNECTED", "CONV_2D", "INPUT", "OUTPUT"],

ai_edge_quantizer/model_modifier.py

@@ -21,6 +21,7 @@ import logging
 
 import numpy as np
 
+from ai_edge_litert.tools import flatbuffer_utils
 from ai_edge_quantizer import qtyping
 from ai_edge_quantizer import transformation_instruction_generator
 from ai_edge_quantizer import transformation_performer
@@ -28,7 +29,6 @@ from ai_edge_quantizer.utils import tfl_flatbuffer_utils
 from ai_edge_quantizer.utils import tfl_interpreter_utils
 from ai_edge_litert import interpreter as tfl  # pylint: disable=g-direct-tensorflow-import
 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
 
 
 _DEQUANT_SUFFIX = "_dequant"

ai_edge_quantizer/model_modifier_test.py

@@ -19,13 +19,13 @@ import os
 import tracemalloc
 from tensorflow.python.platform import googletest
 from absl.testing import parameterized
+from ai_edge_litert.tools import flatbuffer_utils
 from ai_edge_quantizer import model_modifier
 from ai_edge_quantizer import params_generator
 from ai_edge_quantizer import qtyping
 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 tensorflow.lite.tools import flatbuffer_utils  # pylint: disable=g-direct-tensorflow-import
 
 TEST_DATA_PREFIX_PATH = test_utils.get_path_to_datafile('.')
 

ai_edge_quantizer/model_validator.py

@@ -25,7 +25,7 @@ from typing import Any, Optional, Union
 import numpy as np
 
 from ai_edge_quantizer.utils import tfl_interpreter_utils as utils
-from tensorflow.python.platform import gfile  # pylint: disable=g-direct-tensorflow-import
+import os # tensorflow.python.platform.gfile  # pylint: disable=g-direct-tensorflow-import
 
 
 _DEFAULT_SIGNATURE_KEY = utils.DEFAULT_SIGNATURE_KEY
@@ -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,
@@ -192,7 +194,7 @@ class ComparisonResult:
     result_save_path = os.path.join(
         save_folder, model_name + '_comparison_result.json'
     )
-    with gfile.GFile(result_save_path, 'w') as output_file_handle:
+    with open(result_save_path, 'w') as output_file_handle:
       output_file_handle.write(json.dumps(result))
 
     # TODO: b/365578554 - Remove after ME is updated to use the new json format.
@@ -204,7 +206,7 @@ class ComparisonResult:
     json_save_path = os.path.join(
         save_folder, model_name + '_comparison_result_me_input.json'
     )
-    with gfile.GFile(json_save_path, 'w') as output_file_handle:
+    with open(json_save_path, 'w') as output_file_handle:
       output_file_handle.write(json_object)
 
 
@@ -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/qtyping.py

@@ -67,6 +67,7 @@ class TFLOperationName(str, enum.Enum):
   SQUARED_DIFFERENCE = 'SQUARED_DIFFERENCE'
   MAX_POOL_2D = 'MAX_POOL_2D'
   RESIZE_BILINEAR = 'RESIZE_BILINEAR'
+  RESIZE_NEAREST_NEIGHBOR = 'RESIZE_NEAREST_NEIGHBOR'
   GATHER_ND = 'GATHER_ND'
   PACK = 'PACK'
   UNPACK = 'UNPACK'
@@ -82,6 +83,7 @@ class TFLOperationName(str, enum.Enum):
   NOT_EQUAL = 'NOT_EQUAL'
   MIRROR_PAD = 'MIRROR_PAD'
   SPACE_TO_DEPTH = 'SPACE_TO_DEPTH'
+  RELU = 'RELU'
 
 
 class QuantizeMode(enum.Enum):

ai_edge_quantizer/quantizer.py

@@ -33,7 +33,7 @@ from ai_edge_quantizer import recipe_manager
 from ai_edge_quantizer.utils import tfl_flatbuffer_utils
 from ai_edge_quantizer.utils import tfl_interpreter_utils
 from ai_edge_quantizer.utils import validation_utils
-from tensorflow.python.platform import gfile  # pylint: disable=g-direct-tensorflow-import
+import os # tensorflow.python.platform.gfile  # pylint: disable=g-direct-tensorflow-import
 
 
 # Expose algorithm names to users.
@@ -74,15 +74,15 @@ class QuantizationResult:
     Raises:
       RuntimeError: If no quantized model is available.
     """
-    if not gfile.Exists(save_folder):
-      gfile.MakeDirs(save_folder)
+    if not os.path.exists(save_folder):
+      os.makedirs(save_folder)
 
     model_save_path = os.path.join(save_folder, f'{model_name}.tflite')
     self.export_model(model_save_path, overwrite)
 
     recipe_save_path = os.path.join(save_folder, model_name + '_recipe.json')
     recipe = json.dumps(self.recipe)
-    with gfile.GFile(recipe_save_path, 'w') as output_file_handle:
+    with open(recipe_save_path, 'w') as output_file_handle:
       output_file_handle.write(recipe)
 
   def export_model(self, filepath: str, overwrite: bool = False) -> None:
@@ -102,7 +102,7 @@ class QuantizationResult:
       raise RuntimeError(
           'No quantized model to save. Make sure .quantize() is called.'
       )
-    if gfile.Exists(filepath):
+    if os.path.exists(filepath):
       if overwrite:
         logging.warning(
             'The model %s already exists in the folder. Overwriting the model'
@@ -115,7 +115,7 @@ class QuantizationResult:
             ' consider change the model name or specify overwrite=True to'
             ' overwrite the model if needed.'
         )
-    with gfile.GFile(filepath, 'wb') as output_file_handle:
+    with open(filepath, 'wb') as output_file_handle:
       output_file_handle.write(self.quantized_model)
 
 
@@ -179,7 +179,7 @@ class Quantizer:
       recipe: Quantization recipe in json format.
     """
     if isinstance(recipe, str):
-      with gfile.Open(recipe) as json_file:
+      with open(recipe) as json_file:
         recipe = json.load(json_file)
     self._recipe_manager.load_quantization_recipe(recipe)
 
@@ -191,7 +191,7 @@ class Quantizer:
     Args:
       filename: Config policy filename.
     """
-    with gfile.Open(filename, 'r') as f:
+    with open(filename, 'r') as f:
       policy = default_policy.update_default_config_policy(f.read())
 
     # Register the policy for MIN_MAX_UNIFORM_QUANT algorithm.
@@ -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/recipe_manager.py

@@ -108,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()
 

ai_edge_quantizer/recipe_manager_test.py

@@ -241,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
@@ -293,6 +280,31 @@ 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/.*',

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/calibration_utils.py

@@ -20,12 +20,12 @@ from typing import Any, Union
 
 import numpy as np
 
+from ai_edge_litert.tools import flatbuffer_utils
 from ai_edge_quantizer import qtyping
 from ai_edge_quantizer.algorithms.utils import common_utils
 from ai_edge_quantizer.utils import constrained_ops_utils
 from ai_edge_quantizer.utils import tfl_flatbuffer_utils
 from ai_edge_quantizer.utils import tfl_interpreter_utils
-from tensorflow.lite.tools import flatbuffer_utils  # pylint: disable=g-direct-tensorflow-import
 
 
 _SignatureInput = dict[str, Any]

ai_edge_quantizer/utils/calibration_utils_test.py

@@ -15,7 +15,6 @@
 
 from absl.testing import parameterized
 import numpy as np
-import tensorflow as tf
 
 from tensorflow.python.platform import googletest
 from ai_edge_quantizer import quantizer
@@ -132,7 +131,7 @@ class CalibrationQsvAlignmentUtilsTest(parameterized.TestCase):
   def test_calibration_utils_init_fails(self):
     model_path = "non_existent_model.tflite"
     with self.assertRaisesWithPredicateMatch(
-        tf.errors.NotFoundError, lambda err: f"{model_path}" in str(err)
+        Exception, lambda err: f"{model_path}" in str(err)
     ):
       calibration_utils.CalibrationQsvAlignmentUtils(model_path)
 

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/constrained_ops_utils_test.py

@@ -28,7 +28,7 @@ class ConstrainedOpsUtilsTest(parameterized.TestCase):
       dict(
           testcase_name="same_as_input_scale",
           constraint=_OpQuantConstraint.SAME_AS_INPUT_SCALE,
-          expected_num_ops=17,
+          expected_num_ops=18,
       ),
       dict(
           testcase_name="same_as_output_scale",
@@ -38,7 +38,7 @@ class ConstrainedOpsUtilsTest(parameterized.TestCase):
       dict(
           testcase_name="no_constrain",
           constraint=_OpQuantConstraint.NO_CONSTRAIN,
-          expected_num_ops=24,
+          expected_num_ops=25,
       ),
   )
   def test_get_constrained_op_list(self, constraint, expected_num_ops):

ai_edge_quantizer/utils/tfl_flatbuffer_utils.py

@@ -20,10 +20,10 @@ from typing import Any, Optional, Union
 import immutabledict
 import numpy as np
 
+from ai_edge_litert.tools import flatbuffer_utils
 from ai_edge_quantizer import qtyping
 from ai_edge_litert import schema_py_generated as schema  # pylint:disable=g-direct-tensorflow-import
-from tensorflow.lite.tools import flatbuffer_utils  # pylint: disable=g-direct-tensorflow-import
-from tensorflow.python.platform import gfile  # pylint: disable=g-direct-tensorflow-import
+import os # tensorflow.python.platform.gfile  # pylint: disable=g-direct-tensorflow-import
 
 _TFLOpName = qtyping.TFLOperationName
 
@@ -61,6 +61,9 @@ TFL_OP_NAME_TO_CODE = immutabledict.immutabledict({
     _TFLOpName.SQUARED_DIFFERENCE: schema.BuiltinOperator.SQUARED_DIFFERENCE,
     _TFLOpName.MAX_POOL_2D: schema.BuiltinOperator.MAX_POOL_2D,
     _TFLOpName.RESIZE_BILINEAR: schema.BuiltinOperator.RESIZE_BILINEAR,
+    _TFLOpName.RESIZE_NEAREST_NEIGHBOR: (
+        schema.BuiltinOperator.RESIZE_NEAREST_NEIGHBOR
+    ),
     _TFLOpName.GATHER_ND: schema.BuiltinOperator.GATHER_ND,
     _TFLOpName.PACK: schema.BuiltinOperator.PACK,
     _TFLOpName.UNPACK: schema.BuiltinOperator.UNPACK,
@@ -76,6 +79,7 @@ TFL_OP_NAME_TO_CODE = immutabledict.immutabledict({
     _TFLOpName.NOT_EQUAL: schema.BuiltinOperator.NOT_EQUAL,
     _TFLOpName.MIRROR_PAD: schema.BuiltinOperator.MIRROR_PAD,
     _TFLOpName.SPACE_TO_DEPTH: schema.BuiltinOperator.SPACE_TO_DEPTH,
+    _TFLOpName.RELU: schema.BuiltinOperator.RELU,
 })
 
 TFL_OP_CODE_TO_NAME = immutabledict.immutabledict(
@@ -106,7 +110,7 @@ TENSOR_TYPE_TO_CODE = immutabledict.immutabledict(
     (reversed(item) for item in TENSOR_CODE_TO_TYPE.items())
 )
 
-# Expose functions in tensorflow.lite.tools.flatbuffer_utils
+# Expose functions in litert.python.tools.flatbuffer_utils
 write_model = flatbuffer_utils.write_model
 
 
@@ -141,7 +145,7 @@ def get_model_content(tflite_path: str) -> bytes:
   Returns:
     The model bytes.
   """
-  with gfile.Open(tflite_path, "rb") as tflite_file:
+  with open(tflite_path, "rb") as tflite_file:
     return tflite_file.read()
 
 
@@ -154,7 +158,7 @@ def get_model_buffer(tflite_path: str) -> bytearray:
   Returns:
     model_buffer: the model buffer.
   """
-  with gfile.Open(tflite_path, "rb") as tflite_file:
+  with open(tflite_path, "rb") as tflite_file:
     return bytearray(tflite_file.read())
 
 
@@ -207,7 +211,7 @@ def parse_fc_bmm_conv_tensors(
   return input_tensor, weight_tensor, bias_tensor, output_tensor
 
 
-# flatbuffer_model has Any type since tensorflow.lite.tools.flatbuffer_utils
+# flatbuffer_model has Any type since litert.python.tools.flatbuffer_utils
 # is not type annotated.
 def buffer_to_tensors(flatbuffer_model: Any) -> dict[int, list[Any]]:
   """Returns a map from buffer id to tensors that use it."""

ai_edge_quantizer/utils/tfl_interpreter_utils.py

@@ -23,7 +23,7 @@ import numpy as np
 from ai_edge_quantizer import qtyping
 from ai_edge_quantizer.algorithms.uniform_quantize import uniform_quantize_tensor
 from ai_edge_litert import interpreter as tfl  # pylint: disable=g-direct-tensorflow-import
-from tensorflow.python.platform import gfile  # pylint: disable=g-direct-tensorflow-import
+import os # tensorflow.python.platform.gfile  # pylint: disable=g-direct-tensorflow-import
 
 DEFAULT_SIGNATURE_KEY = "serving_default"
 
@@ -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,12 +44,14 @@ 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.
   """
   if isinstance(tflite_model, str):
-    with gfile.GFile(tflite_model, "rb") as f:
+    with open(tflite_model, "rb") as f:
       tflite_model = f.read()
 
   if use_xnnpack:
@@ -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.dev20251130.dist-info → ai_edge_quantizer_nightly-0.5.0.dev20260112.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-edge-quantizer-nightly
-Version: 0.5.0.dev20251130
+Version: 0.5.0.dev20260112
 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
@@ -24,9 +24,10 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: absl-py
 Requires-Dist: immutabledict
 Requires-Dist: numpy
-Requires-Dist: tf-nightly
+Requires-Dist: ml_dtypes
 Requires-Dist: ai-edge-litert-nightly
 Dynamic: classifier
 Dynamic: description

{ai_edge_quantizer_nightly-0.5.0.dev20251130.dist-info → ai_edge_quantizer_nightly-0.5.0.dev20260112.dist-info}/RECORD

@@ -1,25 +1,25 @@
 ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
-ai_edge_quantizer/algorithm_manager.py,sha256=0jSNITKl0Ge1XeYKueOUj9brlS4B5ZcdcVQ1kZS3JKg,16518
+ai_edge_quantizer/algorithm_manager.py,sha256=ZJcmIBREZ7maqxQbMkvwGaQhTxYWFHrdiqNF6c53Jb8,16846
 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/default_policy.py,sha256=ou__mTzh6hcrO2-_ZHxhOZjbVLAwNfCzckxcyISYRMc,11431
+ai_edge_quantizer/model_modifier.py,sha256=RxzfB1UULxLZlFEtgvFu0WrdTo7SLofc52KZchV_2vQ,10421
+ai_edge_quantizer/model_modifier_test.py,sha256=5vUCodVNk9GPcecjGwovV0677vD0BUZjfq9PGOnMEmM,7227
+ai_edge_quantizer/model_validator.py,sha256=mU6MLMvNQK7fxEJmh11H44OGnkUof0CVP6kYjb_du2A,13931
 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/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/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=RPJTlcculzgx_QxAU6I_TS6JnJYTlqnx2WfxnLKK1dg,18081
+ai_edge_quantizer/quantizer.py,sha256=dgBkHR1VXuXzwKKdv7D39OL2z0ASp30xbN0vwFUX31M,19125
+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_manager.py,sha256=OcnrY8Qj_kjDIXx71RX1MHw5qND89N-DKuMRajfGMEg,15205
+ai_edge_quantizer/recipe_manager_test.py,sha256=pLEnLX8zwfZu9LcZoU0a8QpxNr8IFwbGdxp-hlYEwU4,37050
 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=7xLbcm34nRnKLi3Rb_SdGNuXrXwEuC0t6hNAY3d0aSM,42129
 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,12 +36,12 @@ 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
 ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor.py,sha256=qZxTj3B-tqNTLCViwuJj285YncvwjWeay2QKWd8nr6A,20420
-ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor_test.py,sha256=eTrrc8AGaSf1Ytp5gsRONAZ94PHFJUTd4dGi5ZnKZjU,16038
+ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor_test.py,sha256=2BBSNqB37Smo8t9CZJShlT6JZMpuw4RWRvAGHBTr3OA,16417
 ai_edge_quantizer/algorithms/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
 ai_edge_quantizer/algorithms/utils/common_utils.py,sha256=M3VZsdLC4jCPfSI_aGAY4XjiHvoXtR-UyPZdZdz8GD0,38082
 ai_edge_quantizer/algorithms/utils/common_utils_test.py,sha256=zqapGEfYhjQWe9cNGPLmdbwtEUUYQRhlO_kNe0cXX6E,18104
@@ -63,19 +63,19 @@ ai_edge_quantizer/transformations/quantize_tensor_test.py,sha256=CD7OboBcIQxQY8O
 ai_edge_quantizer/transformations/transformation_utils.py,sha256=IKrtXJNH0msiTcI7KXkCYn2EkzmbZKWMMX_r5PMEx2U,8857
 ai_edge_quantizer/transformations/transformation_utils_test.py,sha256=MWgq29t7rvxRQIfi4ny9IoODFCTcbpjnIwoCL40zDKk,8698
 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_test.py,sha256=i_uERo-KvMj0dvUSuI67kdOBHvRQETg8-qnejs_MgTE,1756
+ai_edge_quantizer/utils/calibration_utils.py,sha256=dFDsjc3CXaDFNbCMyoPrMVubd3EDtG0ZwIY3Tmbb0sw,11506
+ai_edge_quantizer/utils/calibration_utils_test.py,sha256=jod4iokZkG00y9JrYaFzVvg4JwiA6mX8_whAMkNyoEc,9334
+ai_edge_quantizer/utils/constrained_ops_utils.py,sha256=z0sm1R9anRRVgdgI23XQKwDRcdARdpTo_6UBDB_lHXE,4502
+ai_edge_quantizer/utils/constrained_ops_utils_test.py,sha256=zmMIAS1WIvYK1Z9ZMMxYovIGtxfek-jvfZqrois1ahE,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.py,sha256=3mngikx_lF-qKBc5KxGX-5kELH_XGKpeGjwUyR5dfZI,12167
 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=ptdlC3WVUE9aBznT7kZQ0ZOk3EKgOBQdMDAaCdGedIM,15093
+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.dev20251130.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.5.0.dev20251130.dist-info/METADATA,sha256=bkOsJLKqRynroS7W0blZKvvFESlG3DZh4xHs_Vx9Y1A,1707
-ai_edge_quantizer_nightly-0.5.0.dev20251130.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-ai_edge_quantizer_nightly-0.5.0.dev20251130.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.5.0.dev20251130.dist-info/RECORD,,
+ai_edge_quantizer_nightly-0.5.0.dev20260112.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.5.0.dev20260112.dist-info/METADATA,sha256=9m2IZe6HAZtu2zhhOej5CbUIB2OiyQTlCCCJzBvk6Es,1729
+ai_edge_quantizer_nightly-0.5.0.dev20260112.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+ai_edge_quantizer_nightly-0.5.0.dev20260112.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.5.0.dev20260112.dist-info/RECORD,,