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

ai_edge_quantizer/algorithm_manager.py

@@ -100,6 +100,7 @@ MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT = {
     _TFLOpName.DYNAMIC_UPDATE_SLICE: (
         common_quantize.materialize_dynamic_update_slice
     ),
+    _TFLOpName.STABLEHLO_COMPOSITE: common_quantize.materialize_composite,
 }
 for op_name, materialize_func in MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT.items():
   register_quantized_op(

ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py

@@ -110,6 +110,21 @@ def materialize_output(
   )
 
 
+def materialize_composite(
+    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 the virtual output op."""
+  return common_utils.materialize_standard_op(
+      op_info,
+      graph_info,
+      tensor_name_to_qsv,
+      get_tensor_quant_params_fn,
+  )
+
+
 def materialize_add(
     get_tensor_quant_params_fn: qtyping.GetTensorQuantParamsFuncSignature,
     op_info: qtyping.OpInfo,

ai_edge_quantizer/algorithms/utils/common_utils.py

@@ -86,7 +86,6 @@ def check_if_valid_op_config(
   Raises:
     ValueError: If the op quantization config is not valid.
   """
-
   check_passed = False
   error_msg = ""
   # Check if find op_config in policy config_check_policy.

ai_edge_quantizer/calibrator.py

@@ -23,6 +23,7 @@ from absl import logging
 import numpy as np
 
 from ai_edge_quantizer import algorithm_manager
+from ai_edge_quantizer import default_policy as policy
 from ai_edge_quantizer import qtyping
 from ai_edge_quantizer import recipe_manager
 from ai_edge_quantizer.utils import calibration_utils
@@ -124,50 +125,62 @@ class Calibrator:
         )
         if cache_output:
           self._cached_output.append(signature_output)
-        self._tensor_content_map.update(
-            tfl_interpreter_utils.get_tensor_name_to_content_map(
-                self._tfl_interpreter, subgraph_idx
-            )
-        )
 
         # Step2: go through each op in subgraph to update quantization
         # statistic values.
-        subgraph = self._flatbuffer_model.subgraphs[subgraph_idx]
-        graph_info = qtyping.GraphInfo(
-            subgraph.tensors, self._flatbuffer_model.buffers
-        )
-        # Add input/output operators to the subgraph.
-        subgraph.operators += (
-            tfl_flatbuffer_utils.get_subgraph_input_output_operators(subgraph)
-        )
-        for op in subgraph.operators:
-          if isinstance(op, qtyping.IOOperator):
-            op_key = op.op_key
-          else:
-            op_code = op_codes[op.opcodeIndex].builtinCode
-            if op_code not in tfl_flatbuffer_utils.TFL_OP_CODE_TO_NAME:
-              continue
-            op_key = tfl_flatbuffer_utils.TFL_OP_CODE_TO_NAME[op_code]
-          # Step2.1: query the quantization_recipe to get op quantization
-          # settings.
-          op_scope = self._get_op_scope(op, subgraph.tensors)
-          algorithm_name, _ = model_recipe_manager.get_quantization_configs(
-              op_key, op_scope
+        subgraphs_inds = [subgraph_idx]
+        while subgraphs_inds:
+          subgraph_ind = subgraphs_inds.pop()
+          self._tensor_content_map.update(
+              tfl_interpreter_utils.get_tensor_name_to_content_map(
+                  self._tfl_interpreter, subgraph_ind
+              )
           )
-          if algorithm_name == algorithm_manager.AlgorithmName.NO_QUANTIZE:
-            continue
-          # Step2.2: query algorithm_manager to get/call the related calibration
-          # function.
-          calibrate_func = algorithm_manager.get_quantization_func(
-              algorithm_name, op_key, qtyping.QuantizeMode.CALIBRATE
+          subgraph = self._flatbuffer_model.subgraphs[subgraph_ind]
+          graph_info = qtyping.GraphInfo(
+              subgraph.tensors, self._flatbuffer_model.buffers
           )
-          op_qsvs = calibrate_func(op, graph_info, self._tensor_content_map)
-          # Step3: Update tensor qsvs with the new values. Ignore the tensor
-          # names that are already updated in this round of calibration.
-          op_updated_tensor_name = self._update_qsvs(
-              op_qsvs, updated_tensor_names, qsv_update_func
+          # Add input/output operators to the subgraph.
+          subgraph.operators += (
+              tfl_flatbuffer_utils.get_subgraph_input_output_operators(subgraph)
           )
-          updated_tensor_names.update(op_updated_tensor_name)
+          for op in subgraph.operators:
+            if isinstance(op, qtyping.IOOperator):
+              op_key = op.op_key
+            else:
+              op_code = op_codes[op.opcodeIndex].builtinCode
+              if op_code not in tfl_flatbuffer_utils.TFL_OP_CODE_TO_NAME:
+                continue
+              op_key = tfl_flatbuffer_utils.TFL_OP_CODE_TO_NAME[op_code]
+            # Step2.1: query the quantization_recipe to get op quantization
+            # settings.
+            op_scope = self._get_op_scope(op, subgraph.tensors)
+            algorithm_name, _ = model_recipe_manager.get_quantization_configs(
+                op_key, op_scope
+            )
+            if algorithm_name == algorithm_manager.AlgorithmName.NO_QUANTIZE:
+              continue
+            if policy.is_conditionally_unquantized(op):
+              continue
+
+            # Step2.2: query algorithm_manager to get/call the related
+            # calibration function.
+            calibrate_func = algorithm_manager.get_quantization_func(
+                algorithm_name, op_key, qtyping.QuantizeMode.CALIBRATE
+            )
+            op_qsvs = calibrate_func(op, graph_info, self._tensor_content_map)
+            # Step3: Update tensor qsvs with the new values. Ignore the tensor
+            # names that are already updated in this round of calibration.
+            op_updated_tensor_name = self._update_qsvs(
+                op_qsvs, updated_tensor_names, qsv_update_func
+            )
+            updated_tensor_names.update(op_updated_tensor_name)
+
+            # Step4: Invoke any subgraphs invoked as a side effect of the op.
+            subgraphs_inds.extend(
+                tfl_flatbuffer_utils.get_op_side_effect_subgraphs(op)
+            )
+
       # Reset interpreter after one round of calibration.
       self._tfl_interpreter.reset_all_variables()
 

ai_edge_quantizer/default_policy.py

@@ -18,8 +18,10 @@
 import collections
 import copy
 import json
-from typing import Any
+from typing import Any, Union
 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
@@ -168,7 +170,9 @@ DEFAULT_JSON_POLICY = """
       "EMBEDDING_LOOKUP",
       "SUM",
       "SELECT_V2",
-      "DYNAMIC_UPDATE_SLICE"
+      "DYNAMIC_UPDATE_SLICE",
+      "SELECT_V2",
+      "STABLEHLO_COMPOSITE"
     ],
     "static_wi8_ai8": [
       "ADD",
@@ -197,7 +201,9 @@ DEFAULT_JSON_POLICY = """
       "EMBEDDING_LOOKUP",
       "SUM",
       "SELECT_V2",
-      "DYNAMIC_UPDATE_SLICE"
+      "DYNAMIC_UPDATE_SLICE",
+      "SELECT_V2",
+      "STABLEHLO_COMPOSITE"
     ],
     "static_wi4_ai8": ["FULLY_CONNECTED", "CONV_2D", "INPUT", "OUTPUT", "EMBEDDING_LOOKUP"],
     "static_wi4_ai16": ["FULLY_CONNECTED", "CONV_2D", "INPUT", "OUTPUT", "EMBEDDING_LOOKUP"],
@@ -288,6 +294,33 @@ def _unroll_json_config(
   return quant_configs
 
 
+# TODO: b/401024954 - Have a better way to specify recipes based on op options.
+def is_conditionally_unquantized(
+    op: Union[schema.Operator, schema.OperatorT],
+) -> bool:
+  """Checks if the operator is conditionally unquantized.
+
+  We may want to quantize an op only when its has certain options.
+  Policies/recipes
+  are not aware of op options, so it is checked here.
+
+  Args:
+    op: The operator to check.
+
+  Returns:
+    True if the operator is conditionally unquantized, False otherwise.
+  """
+  if opts := flatbuffer_utils.get_options_as(
+      op, schema.StableHLOCompositeOptionsT
+  ):
+    name: bytes = opts.name
+    # Non npu_call composites may have a kernel and as such will not be
+    # quantized.
+    return ("od" + "ml.npu_call") not in name.decode("utf-8")
+
+  return False
+
+
 def update_default_config_policy(raw_json_policy: str):
   """Updates the default config check policy."""
   json_policy_content = json.loads(raw_json_policy)

ai_edge_quantizer/params_generator.py

@@ -19,6 +19,7 @@ import copy
 from typing import Any, Optional, Union
 
 from ai_edge_quantizer import algorithm_manager
+from ai_edge_quantizer import default_policy as policy
 from ai_edge_quantizer import qtyping
 from ai_edge_quantizer import recipe_manager
 from ai_edge_quantizer.utils import tfl_flatbuffer_utils
@@ -73,8 +74,12 @@ class ParamsGenerator:
     if model_qsvs is None:
       model_qsvs = {}
 
+    skip_subgraphs = set()
     op_codes = self.flatbuffer_model.operatorCodes
-    for subgraph in self.flatbuffer_model.subgraphs:
+    for sg_ind, subgraph in enumerate(self.flatbuffer_model.subgraphs):
+      if sg_ind in skip_subgraphs:
+        continue
+
       graph_info = qtyping.GraphInfo(
           subgraph.tensors, self.flatbuffer_model.buffers
       )
@@ -103,10 +108,19 @@ class ParamsGenerator:
         algorithm_name, op_quant_config = (
             model_recipe_manager.get_quantization_configs(op_key, op_scope)
         )
+        if policy.is_conditionally_unquantized(op):
+          algorithm_name = algorithm_manager.AlgorithmName.NO_QUANTIZE
+
         if algorithm_name == algorithm_manager.AlgorithmName.NO_QUANTIZE:
+          side_effect_subgraphs = (
+              tfl_flatbuffer_utils.get_op_side_effect_subgraphs(op)
+          )
+          skip_subgraphs.update(side_effect_subgraphs)
+
           op_quant_results = self._get_params_for_no_quant_op(
               subgraph_op_id, op, subgraph.tensors
           )
+
         else:
           op_info = qtyping.OpInfo(op, op_key, subgraph_op_id, op_quant_config)
           # Step2: query algorithm_manager to get/call the related function.
@@ -259,17 +273,25 @@ class ParamsGenerator:
       RuntimeError: If the tensors sharing the same buffer have different
         quantization settings.
     """
+    def get_result(tensor: Any):
+      return self.model_quant_results.get(
+          tfl_flatbuffer_utils.get_tensor_name(tensor), None
+      )
+
     for tensors in self.buffer_to_tensors.values():
       if len(tensors) <= 1:
         continue
+
       first_tensor = tensors[0]
-      first_tensor_params = self.model_quant_results[
-          tfl_flatbuffer_utils.get_tensor_name(first_tensor)
-      ]
+      first_tensor_params = get_result(first_tensor)
+      if first_tensor_params is None:
+        continue
+
       for tensor in tensors[1:]:
-        tensor_params = self.model_quant_results[
-            tfl_flatbuffer_utils.get_tensor_name(tensor)
-        ]
+        tensor_params = get_result(tensor)
+        if tensor_params is None:
+          continue
+
         if not _compatible_tensor_transformation_params(
             first_tensor_params, tensor_params
         ):

ai_edge_quantizer/qtyping.py

@@ -61,6 +61,7 @@ class TFLOperationName(str, enum.Enum):
   SUM = 'SUM'
   SELECT_V2 = 'SELECT_V2'
   DYNAMIC_UPDATE_SLICE = 'DYNAMIC_UPDATE_SLICE'
+  STABLEHLO_COMPOSITE = 'STABLEHLO_COMPOSITE'
 
 
 class QuantizeMode(enum.Enum):
@@ -108,6 +109,8 @@ class QuantTransformation(enum.Enum):
   # Create pattern for emulated subchannel quantization, only support fully
   # connected op.
   EMULATED_SUBCHANNEL = 4
+  # Duplicate the buffer.
+  DUPLICATE_BUFFER = 5
 
 
 @dataclasses.dataclass(frozen=True)

ai_edge_quantizer/transformation_instruction_generator.py

@@ -458,49 +458,47 @@ class TransformationInstructionsGenerator:
       self,
       param: qtyping.TensorTransformationParams,
   ) -> qtyping.TensorTransformationInsts:
-    """Converts a single quantization params to transformation instructions.
+    """Convert single tensor quant params to transformation instructions.
 
     Args:
-      param: quantization parameter of a tensor in the graph
+      param: Quantization parameters of a tensor in the graph.
 
     Returns:
-      a list of transformations to be applied to the same tensor
+      Transformations to be applied to the given tensor.
     """
-    # setup the structure
+    # Setup the structure.
     tensor_info = self._tensor_name_to_graph_info[param.tensor_name]
     tensor_trans_insts = qtyping.TensorTransformationInsts(
         param.tensor_name, tensor_info.subgraph_id, []
     )
 
-    # horizontal optimization
-    consumer_group = self._group_consumer_transformations(param)
-    # at this point, starting from index 1 of consumer_group, we're having sets
-    # that represents transformations that can be grouped together
-    transformations_available_for_vertical_optimization = (
-        self._produce_transformation_for_vertical_opt(consumer_group, param)
-    )
-    other_consumer_transformations = (
-        self._produce_consumer_transformations_unavailable_for_vertical_opt(
-            consumer_group, param
-        )
-    )
-
+    # Add all producer rules.
     transformations = []
-    # adding all producer rules
-    producer_params = param.producer
-    if producer_params:
-      for transformation in producer_params.transformations:
+    if param.producer:
+      for transformation in param.producer.transformations:
         transformations.append(
             qtyping.TransformationInst(
                 transformation,
                 tensor_info.tensor_id,
                 tensor_info.producer,
                 tensor_info.consumers,
-                producer_params.parameters,
+                param.producer.parameters,
             )
         )
 
-    # apply vertical optimization
+    # Horizontal optimization.
+    consumer_group = self._group_consumer_transformations(param)
+    # At this point, starting from index 1 of consumer_group, we're having sets
+    # that represent transformations that can be grouped together.
+    transformations_available_for_vertical_optimization = (
+        self._produce_transformation_for_vertical_opt(consumer_group, param)
+    )
+    other_consumer_transformations = (
+        self._produce_consumer_transformations_unavailable_for_vertical_opt(
+            consumer_group, param
+        )
+    )
+    # Apply vertical optimization.
     last_producer_rule_idx = len(transformations) - 1
     if last_producer_rule_idx >= 0:
       transformations += self._apply_vertical_optimization(
@@ -509,11 +507,11 @@ class TransformationInstructionsGenerator:
       )
     else:
       transformations += transformations_available_for_vertical_optimization
-    # Adding other consumers rules
+    # Adding other consumers rules.
     transformations += other_consumer_transformations
     tensor_trans_insts.instructions = transformations
     # Check the generated transformation instructions are valid, the function
-    # will raise an error if the instructions are not valid
+    # will raise an error if the instructions are not valid.
     self._check_tensor_transformation_instructions_valid(tensor_trans_insts)
 
     return tensor_trans_insts

ai_edge_quantizer/transformation_performer.py

@@ -18,6 +18,7 @@
 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
 from ai_edge_quantizer.transformations import emulated_subchannel
 from ai_edge_quantizer.transformations import quant_insert
 from ai_edge_quantizer.transformations import quantize_tensor
@@ -68,6 +69,9 @@ class TransformationPerformer:
             emulated_subchannel.emulated_subchannel
         ),
         qtyping.QuantTransformation.ADD_QUANTIZE: quant_insert.insert_quant,
+        qtyping.QuantTransformation.DUPLICATE_BUFFER: (
+            duplicate_buffer.duplicate_buffer
+        ),
     }
     # transformations are seprated in two categories:
     # op_insertion_transformations are transformations that only insert ops
@@ -77,6 +81,7 @@ class TransformationPerformer:
         qtyping.QuantTransformation.ADD_DEQUANTIZE,
         qtyping.QuantTransformation.QUANTIZE_TENSOR,
         qtyping.QuantTransformation.ADD_QUANTIZE,
+        qtyping.QuantTransformation.DUPLICATE_BUFFER,
     ])
     self._op_replacement_transformations = set(
         [qtyping.QuantTransformation.EMULATED_SUBCHANNEL]

ai_edge_quantizer/transformations/duplicate_buffer.py

@@ -0,0 +1,45 @@
+# Copyright 2024 The AI Edge Quantizer Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Duplicate buffer transformation."""
+
+from ai_edge_quantizer import qtyping
+from ai_edge_quantizer.transformations import transformation_utils
+from ai_edge_quantizer.utils import tfl_flatbuffer_utils
+
+
+def duplicate_buffer(
+    transformation_input: transformation_utils.TransformationInput,
+) -> qtyping.TransformationInfo:
+  """Duplicates the buffer of the tensor."""
+  tensor_id = transformation_input.tensor_id
+  tensor = transformation_input.subgraph.tensors[tensor_id]
+  buffer_data = transformation_input.buffers[tensor.buffer].data
+  if buffer_data is None:
+    tensor_name = tfl_flatbuffer_utils.get_tensor_name(tensor)
+    raise ValueError(
+        'Duplicate Buffer transformation supports only constant tensors.'
+        f' Tensor {tensor_name} is not constant.'
+    )
+
+  duplicated_buffer_id = transformation_utils.add_new_constant_buffer(
+      data=buffer_data,
+      buffers=transformation_input.buffers,
+  )
+  tensor.buffer = duplicated_buffer_id
+
+  return qtyping.TransformationInfo(
+      op_id=0, num_ops_added=0, output_tensor_id=tensor_id
+  )

ai_edge_quantizer/transformations/duplicate_buffer_test.py

@@ -0,0 +1,106 @@
+# Copyright 2024 The AI Edge Quantizer Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import os
+import numpy as np
+from tensorflow.python.platform import googletest
+from ai_edge_quantizer import qtyping
+from ai_edge_quantizer.transformations import duplicate_buffer
+from ai_edge_quantizer.transformations import transformation_utils
+from ai_edge_quantizer.utils import test_utils
+from ai_edge_quantizer.utils import tfl_flatbuffer_utils
+
+TEST_DATA_PREFIX_PATH = test_utils.get_path_to_datafile('..')
+
+
+class DuplicateBufferTest(googletest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    model_path = os.path.join(
+        TEST_DATA_PREFIX_PATH, 'tests/models/weight_sharing_fcs.tflite'
+    )
+    self.model = tfl_flatbuffer_utils.read_model(model_path)
+
+  def _get_transformation_input(
+      self, subgraph_idx: int, tensor_idx: int
+  ) -> transformation_utils.TransformationInput:
+    return transformation_utils.TransformationInput(
+        tensor_id=tensor_idx,
+        buffers=self.model.buffers,
+        # Dummy params below.
+        op_codes=self.model.operatorCodes,
+        subgraph=self.model.subgraphs[subgraph_idx],
+        producer=-1,
+        consumers=[],
+        quant_params=qtyping.UniformQuantParams(
+            num_bits=8,
+            quantized_dimension=None,
+            scale=np.ones(1),
+            zero_point=np.zeros(1),
+        ),
+    )
+
+  def test_constant_buffer_is_correctly_duplicated(self):
+    # Duplicate the FC weight tensor in the second subgraph.
+    subgraph_idx = 1
+    subgraph = self.model.subgraphs[subgraph_idx]
+    weight_tensor_idx = 1
+    prev_buffer_id = subgraph.tensors[weight_tensor_idx].buffer
+    prev_num_buffers = len(self.model.buffers)
+    transformation_input = self._get_transformation_input(
+        subgraph_idx, weight_tensor_idx
+    )
+    transformation_info = duplicate_buffer.duplicate_buffer(
+        transformation_input
+    )
+    self.assertEqual(transformation_info.op_id, 0)
+    self.assertEqual(transformation_info.num_ops_added, 0)
+    self.assertEqual(transformation_info.output_tensor_id, 1)
+    # Check that a new buffer was added.
+    self.assertLen(self.model.buffers, prev_num_buffers + 1)
+    # Check that the new buffer is used by the weight tensor.
+    new_buffer_id = len(self.model.buffers) - 1
+    self.assertEqual(subgraph.tensors[weight_tensor_idx].buffer, new_buffer_id)
+    # Check that the new buffer has the same data as the original one.
+    self.assertTrue(
+        np.all(
+            np.frombuffer(
+                self.model.buffers[new_buffer_id].data,
+                dtype=np.float32,
+            )
+            == np.frombuffer(
+                self.model.buffers[prev_buffer_id].data,
+                dtype=np.float32,
+            )
+        )
+    )
+
+  def test_duplicate_buffer_raises_error_when_tensor_is_not_constant(self):
+    # Duplicate the FC input tensor in the second subgraph.
+    subgraph_idx = 1
+    weight_tensor_idx = 0
+    transformation_input = self._get_transformation_input(
+        subgraph_idx, weight_tensor_idx
+    )
+    with self.assertRaisesRegex(
+        ValueError,
+        'Duplicate Buffer transformation supports only constant tensors.',
+    ):
+      duplicate_buffer.duplicate_buffer(transformation_input)
+
+
+if __name__ == '__main__':
+  googletest.main()

ai_edge_quantizer/transformations/transformation_utils.py

@@ -69,6 +69,29 @@ def add_op_code(
   return len(model_op_codes) - 1
 
 
+def add_new_constant_buffer(
+    data: np.ndarray,
+    buffers: list[schema_py_generated.BufferT],
+) -> int:
+  """Add a new constant buffer to the model.
+
+  Args:
+    data: The data of the new tensor.
+    buffers: The buffers of the model.
+
+  Returns:
+    The index of the new buffer in the model.
+  """
+  new_buffer = schema_py_generated.BufferT()
+  new_buffer.data = np.frombuffer(data.tobytes(), dtype=np.uint8).flatten()
+  new_buffer.offset = 0
+  new_buffer.size = 0
+  new_buffer_id = len(buffers)
+  buffers.append(new_buffer)
+
+  return new_buffer_id
+
+
 def add_new_constant_tensor(
     tensor_name: str,
     data: np.ndarray,
@@ -88,16 +111,11 @@ def add_new_constant_tensor(
   Returns:
     The index of the new tensor in the subgraph.
   """
-  tensor_buffer = schema_py_generated.BufferT()
-  tensor_buffer.data = np.frombuffer(data.tobytes(), dtype=np.uint8).flatten()
-  tensor_buffer.offset = 0
-  tensor_buffer.size = 0
-  tensor_buffer_id = len(buffers)
-  buffers.append(tensor_buffer)
+  new_buffer_id = add_new_constant_buffer(data, buffers)
 
   new_tensor = schema_py_generated.TensorT()
   new_tensor.shape = data.shape
-  new_tensor.buffer = tensor_buffer_id
+  new_tensor.buffer = new_buffer_id
   new_tensor.type = tensor_type
   new_tensor.name = tensor_name
   new_tensor_id = len(subgraph.tensors)

ai_edge_quantizer/transformations/transformation_utils_test.py

@@ -55,6 +55,38 @@ class TransformationUtilsTest(parameterized.TestCase):
     )
     self.assertEqual(expected, got)
 
+  @parameterized.named_parameters(
+      dict(
+          testcase_name="float32",
+          data=np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32),
+      ),
+      dict(
+          testcase_name="int8",
+          data=np.array([[1, 2], [3, 4]], dtype=np.int8),
+      ),
+  )
+  def test_add_new_constant_buffer(self, data):
+    """Tests if the constant buffer is added to the model."""
+    prev_num_buffers = len(self.model.buffers) - 1
+    new_buffer_idx = transformation_utils.add_new_constant_buffer(
+        data=data,
+        buffers=self.model.buffers,
+    )
+    self.assertEqual(new_buffer_idx, prev_num_buffers + 1)
+
+    expected_buffer_data = (
+        np.frombuffer(
+            data.tobytes(),
+            dtype=np.uint8,
+        )
+        .flatten()
+        .tolist()
+    )
+    self.assertEqual(
+        self.model.buffers[new_buffer_idx].data.tolist(),
+        expected_buffer_data,
+    )
+
   @parameterized.named_parameters(
       dict(
           testcase_name="float32",

ai_edge_quantizer/utils/tfl_flatbuffer_utils.py

@@ -21,49 +21,40 @@ import immutabledict
 import numpy as np
 
 from ai_edge_quantizer import qtyping
-from ai_edge_litert import schema_py_generated  # pylint:disable=g-direct-tensorflow-import
+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
 
 _TFLOpName = qtyping.TFLOperationName
 
 TFL_OP_NAME_TO_CODE = immutabledict.immutabledict({
-    _TFLOpName.FULLY_CONNECTED: (
-        schema_py_generated.BuiltinOperator.FULLY_CONNECTED
-    ),
-    _TFLOpName.BATCH_MATMUL: schema_py_generated.BuiltinOperator.BATCH_MATMUL,
-    _TFLOpName.CONV_2D: schema_py_generated.BuiltinOperator.CONV_2D,
-    _TFLOpName.DEPTHWISE_CONV_2D: (
-        schema_py_generated.BuiltinOperator.DEPTHWISE_CONV_2D
-    ),
-    _TFLOpName.CONV_2D_TRANSPOSE: (
-        schema_py_generated.BuiltinOperator.TRANSPOSE_CONV
-    ),
-    _TFLOpName.EMBEDDING_LOOKUP: (
-        schema_py_generated.BuiltinOperator.EMBEDDING_LOOKUP
-    ),
-    _TFLOpName.SOFTMAX: schema_py_generated.BuiltinOperator.SOFTMAX,
-    _TFLOpName.AVERAGE_POOL_2D: (
-        schema_py_generated.BuiltinOperator.AVERAGE_POOL_2D
-    ),
-    _TFLOpName.RESHAPE: schema_py_generated.BuiltinOperator.RESHAPE,
-    _TFLOpName.TANH: schema_py_generated.BuiltinOperator.TANH,
-    _TFLOpName.TRANSPOSE: schema_py_generated.BuiltinOperator.TRANSPOSE,
-    _TFLOpName.GELU: schema_py_generated.BuiltinOperator.GELU,
-    _TFLOpName.ADD: schema_py_generated.BuiltinOperator.ADD,
-    _TFLOpName.SUB: schema_py_generated.BuiltinOperator.SUB,
-    _TFLOpName.MUL: schema_py_generated.BuiltinOperator.MUL,
-    _TFLOpName.MEAN: schema_py_generated.BuiltinOperator.MEAN,
-    _TFLOpName.RSQRT: schema_py_generated.BuiltinOperator.RSQRT,
-    _TFLOpName.CONCATENATION: schema_py_generated.BuiltinOperator.CONCATENATION,
-    _TFLOpName.STRIDED_SLICE: schema_py_generated.BuiltinOperator.STRIDED_SLICE,
-    _TFLOpName.SPLIT: schema_py_generated.BuiltinOperator.SPLIT,
-    _TFLOpName.LOGISTIC: schema_py_generated.BuiltinOperator.LOGISTIC,
-    _TFLOpName.SLICE: schema_py_generated.BuiltinOperator.SLICE,
-    _TFLOpName.SUM: schema_py_generated.BuiltinOperator.SUM,
-    _TFLOpName.SELECT_V2: schema_py_generated.BuiltinOperator.SELECT_V2,
+    _TFLOpName.FULLY_CONNECTED: schema.BuiltinOperator.FULLY_CONNECTED,
+    _TFLOpName.BATCH_MATMUL: schema.BuiltinOperator.BATCH_MATMUL,
+    _TFLOpName.CONV_2D: schema.BuiltinOperator.CONV_2D,
+    _TFLOpName.DEPTHWISE_CONV_2D: schema.BuiltinOperator.DEPTHWISE_CONV_2D,
+    _TFLOpName.CONV_2D_TRANSPOSE: schema.BuiltinOperator.TRANSPOSE_CONV,
+    _TFLOpName.EMBEDDING_LOOKUP: schema.BuiltinOperator.EMBEDDING_LOOKUP,
+    _TFLOpName.SOFTMAX: schema.BuiltinOperator.SOFTMAX,
+    _TFLOpName.AVERAGE_POOL_2D: schema.BuiltinOperator.AVERAGE_POOL_2D,
+    _TFLOpName.RESHAPE: schema.BuiltinOperator.RESHAPE,
+    _TFLOpName.TANH: schema.BuiltinOperator.TANH,
+    _TFLOpName.TRANSPOSE: schema.BuiltinOperator.TRANSPOSE,
+    _TFLOpName.GELU: schema.BuiltinOperator.GELU,
+    _TFLOpName.ADD: schema.BuiltinOperator.ADD,
+    _TFLOpName.SUB: schema.BuiltinOperator.SUB,
+    _TFLOpName.MUL: schema.BuiltinOperator.MUL,
+    _TFLOpName.MEAN: schema.BuiltinOperator.MEAN,
+    _TFLOpName.RSQRT: schema.BuiltinOperator.RSQRT,
+    _TFLOpName.CONCATENATION: schema.BuiltinOperator.CONCATENATION,
+    _TFLOpName.STRIDED_SLICE: schema.BuiltinOperator.STRIDED_SLICE,
+    _TFLOpName.SPLIT: schema.BuiltinOperator.SPLIT,
+    _TFLOpName.LOGISTIC: schema.BuiltinOperator.LOGISTIC,
+    _TFLOpName.SLICE: schema.BuiltinOperator.SLICE,
+    _TFLOpName.SUM: schema.BuiltinOperator.SUM,
+    _TFLOpName.SELECT_V2: schema.BuiltinOperator.SELECT_V2,
+    _TFLOpName.STABLEHLO_COMPOSITE: schema.BuiltinOperator.STABLEHLO_COMPOSITE,
     _TFLOpName.DYNAMIC_UPDATE_SLICE: (
-        schema_py_generated.BuiltinOperator.DYNAMIC_UPDATE_SLICE
+        schema.BuiltinOperator.DYNAMIC_UPDATE_SLICE
     ),
 })
 
@@ -318,3 +309,23 @@ def get_subgraph_input_output_operators(
       op_key=qtyping.TFLOperationName.OUTPUT,
   )
   return [input_op, output_op]
+
+
+def get_op_side_effect_subgraphs(
+    op: Union[schema.Operator, schema.OperatorT],
+) -> list[int]:
+  """Get indices of any subgraphs invoked as a side effect of the operator.
+
+  Args:
+    op: The operator object.
+
+  Returns:
+    A list of subgraph indices invoked by the operator. Empty if the operator
+    does not invoke any subgraphs.
+  """
+  if opts := flatbuffer_utils.get_options_as(
+      op, schema.StableHLOCompositeOptionsT
+  ):
+    return [opts.decompositionSubgraphIndex]
+  # Can add other nested ops here (control flow ops, etc).
+  return []

ai_edge_quantizer/utils/tfl_interpreter_utils.py

@@ -216,8 +216,10 @@ def get_tensor_name_to_details_map(
   """
   tensor_name_to_detail = {}
   for tensor_detail in tflite_interpreter.get_tensor_details(subgraph_index):
-    # Don't return temporary, unnamed tensors
-    if not tensor_detail["name"]:
+    # Don't return temporary, unnamed tensors or scratch tensors.
+    # tensor_detail doesn't include the allocation size (bytes) or an
+    # indicator of scratch tensors, so use the name to filter them out.
+    if not tensor_detail["name"] or "scratch" in tensor_detail["name"]:
       continue
     tensor_name_to_detail[tensor_detail["name"]] = tensor_detail
   return tensor_name_to_detail

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

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

@@ -1,34 +1,34 @@
 ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
-ai_edge_quantizer/algorithm_manager.py,sha256=4PPqKQcOLDsrY_LhyPvTQsSfH_fpuBmKzz3Uins1UK4,7637
+ai_edge_quantizer/algorithm_manager.py,sha256=VZx4HvGEgt6XAS-b0breFPioLfKkAFNG71VLSG4aKS8,7712
 ai_edge_quantizer/algorithm_manager_api.py,sha256=u903TG0s1uIDhJqfeJne3CFl8A93phZrwgV2-hwdcXU,9247
 ai_edge_quantizer/algorithm_manager_api_test.py,sha256=tL_ozYFTsOPX8qGcti0KTz37nVsCxf0SSG5C45SyT-g,7319
-ai_edge_quantizer/calibrator.py,sha256=2J-bX0k09A7vZSRnO3eP49YO2uBMUQh6-sk3JRz9fGQ,11363
+ai_edge_quantizer/calibrator.py,sha256=n7AD9j7UScR-CieoI6DQRMeiG_fhLBfSLRiM4460xaM,11895
 ai_edge_quantizer/calibrator_test.py,sha256=C_oWOaRugPKYX74jF-eRFH-k6nGOdA8I9_uPiocaOuE,11900
 ai_edge_quantizer/conftest.py,sha256=SxCz-5LlRD_lQm4hQc4c6IGG7DS8d7IyEWY9gnscPN0,794
-ai_edge_quantizer/default_policy.py,sha256=CgArJLygD3eJ2g9ur-i1M9DLb3Tb8yy3hiJfyeikixA,9179
+ai_edge_quantizer/default_policy.py,sha256=2y9p7iZIESB4ozPwjiodgPTLlnmHxQKkwKcYSfc80JI,10277
 ai_edge_quantizer/model_modifier.py,sha256=Z8EYtrz4zhCFpzd1zVwl2AetVE3BGBf5OvB2DbVQuds,5850
 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=FvBub5yM2q98k7wNLgEyRerf8sVIETvGbrFcXFPUPdA,13523
+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/qtyping.py,sha256=qeSxsbU0aEzBMgjvM4a4iYWx1xT7L5Sk5ZyON7xJWWU,15140
+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/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=l_n7bXxIPTQ9AGcl2dkSx_BgJNtSs8ZW_JZ3pxtQ1I0,21652
+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=3ZuaN5xwAu1B9zoGZHqi0__FOSzjGWOcydpCy1_Scac,10951
+ai_edge_quantizer/transformation_performer.py,sha256=4GCCOw5WBhO0UUfFoLlbfUh3RfnffF9qI_yEpdWlyps,11181
 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
 ai_edge_quantizer/algorithms/nonlinear_quantize/float_casting.py,sha256=Bs9CK7wZAw6jNaZ8xEtbwO2vM34VYXNZSMVWvxJo9nw,9297
 ai_edge_quantizer/algorithms/nonlinear_quantize/float_casting_test.py,sha256=s64eDDH9bmRWy6Bl1peHnhGewLnFJjvnhYOdjo1zYOA,22625
 ai_edge_quantizer/algorithms/uniform_quantize/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=l3wJXoyXJXULeSEx3_BzbtIxLzotziT1mQembF9A1RE,21877
+ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=osvXIwVVEi5DRiT_MpJpAXGZCVMEoR0tcc6EwuAtcp0,22330
 ai_edge_quantizer/algorithms/uniform_quantize/common_quantize_test.py,sha256=qMmKbWqxrCoVKbLKHn9WuCrGKPfHkEyU0Nmhokh8Qeo,2597
 ai_edge_quantizer/algorithms/uniform_quantize/dequantized_weight_recovery.py,sha256=OTXjEZ3Ctq3ffYzisX-6HwgK_DuA7uos_aap5PiIUPE,8686
 ai_edge_quantizer/algorithms/uniform_quantize/dequantized_weight_recovery_test.py,sha256=y7BK11fkF63Ex_Jzg3fbIdy0D_Ca6HuvChVZR7Uwggc,8073
@@ -37,31 +37,33 @@ ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize_test.py,sha
 ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor.py,sha256=Q_vx7YN7KMpjubsngxRdJ4bfdSIV-gmXjtVuxIkZuX4,11078
 ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor_test.py,sha256=WZ4_bvbG999nOtCIqn7mrMnpRdoJOdiyzxhsL_QiPHA,11395
 ai_edge_quantizer/algorithms/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/utils/common_utils.py,sha256=nlLpUY1LTO9ZC3X0FjQ0EArCZekGUnv2-IF0AUu5zNM,34582
+ai_edge_quantizer/algorithms/utils/common_utils.py,sha256=4qSlVNx3-91kJufnnJV1RdVRXBPapylZkrAp2nywoao,34581
 ai_edge_quantizer/algorithms/utils/common_utils_test.py,sha256=zqapGEfYhjQWe9cNGPLmdbwtEUUYQRhlO_kNe0cXX6E,18104
 ai_edge_quantizer/transformations/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
 ai_edge_quantizer/transformations/dequant_insert.py,sha256=sL1LHFVzBDSd9jgrzlHz38LWU0bwmVX7iBkaNcui0ts,3566
 ai_edge_quantizer/transformations/dequant_insert_test.py,sha256=NJ18PnG71_AvUPz3Cr_TmG6URMeBfa7IiDDyddfTkKQ,10830
+ai_edge_quantizer/transformations/duplicate_buffer.py,sha256=sEod0EtmcHX0VDqBCI4BYCX9CSRyDtx2vmjtOentFiY,1743
+ai_edge_quantizer/transformations/duplicate_buffer_test.py,sha256=YYWl3Q5WF60s8T8pLzzA8TCSxz-i7dqc03dJt1LtMw4,3880
 ai_edge_quantizer/transformations/emulated_subchannel.py,sha256=HVaRxoC8PCAvy3xeMv3OIymukUy_yW1zK0xN8Ann6I4,13602
 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/transformation_utils.py,sha256=BaKy5LYWgqli62XGo3AGRDNtHjwpBNp5VF5XgFbfVmg,4298
-ai_edge_quantizer/transformations/transformation_utils_test.py,sha256=ks81nNvruOC88Tjdk3_qwku0V8p54p3gOqfObzNhWMM,5371
+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
 ai_edge_quantizer/utils/calibration_utils.py,sha256=1Fj9MIO6aLZIRgyd4axvZN4S_O64nB_-Miu1WP664js,2536
 ai_edge_quantizer/utils/calibration_utils_test.py,sha256=Z-AcdTieesWFKyKBb08ZXm4Mgu6cvJ4bg2-MJ7hLD10,2856
 ai_edge_quantizer/utils/test_utils.py,sha256=HwZCIpO9fJRAhuN6t6voXKOYQtcioFtt_tpkAlDsAYk,6205
-ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=pI4JWq_rhp1tRWwNSFMzbWx-3YEQWQir-bM6S88WKIw,10237
+ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=_A-h_MqwElzjgkLDmXTZ1iAIWtTRcLjSFGfjNT8fuHU,10480
 ai_edge_quantizer/utils/tfl_flatbuffer_utils_test.py,sha256=AbyDxoM62k4ojD8gPdkWo--xe5hlX3t0kobQSA80kuk,7740
-ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=ZI16i25bAOpnJUBgRg38EH2CuZ55wxyHFScM12RsOwc,12487
+ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=x2xA2CFPpe_2trcV8v5xGaBETvVCfwAcJuq6yieGJ0Y,12687
 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.dev20250310.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.0.1.dev20250310.dist-info/METADATA,sha256=PiporO2Ccbi6HhC54nai7NC7Tf8cg7sJA1Cb6laF310,1528
-ai_edge_quantizer_nightly-0.0.1.dev20250310.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ai_edge_quantizer_nightly-0.0.1.dev20250310.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.0.1.dev20250310.dist-info/RECORD,,
+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,,