ai-edge-quantizer-nightly 0.0.1.dev20250304__py3-none-any.whl → 0.0.1.dev20250306__py3-none-any.whl

ai_edge_quantizer/algorithm_manager.py

@@ -97,6 +97,9 @@ MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT = {
     _TFLOpName.SLICE: common_quantize.materialize_slice,
     _TFLOpName.SUM: common_quantize.materialize_sum,
     _TFLOpName.SELECT_V2: common_quantize.materialize_select_v2,
+    _TFLOpName.DYNAMIC_UPDATE_SLICE: (
+        common_quantize.materialize_dynamic_update_slice
+    ),
 }
 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

@@ -375,6 +375,25 @@ def materialize_select_v2(
   )
 
 
+def materialize_dynamic_update_slice(
+    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.dynamic_update_slice."""
+  return common_utils.materialize_standard_op(
+      op_info,
+      graph_info,
+      tensor_name_to_qsv,
+      get_tensor_quant_params_fn,
+      constraint=_OpQuantConstraint.SAME_AS_OUTPUT_SCALE,
+      inputs_to_ignore=[
+          2,
+      ],  # start_indices do not need to be quantized.
+  )
+
+
 def materialize_sum(
     get_tensor_quant_params_fn: qtyping.GetTensorQuantParamsFuncSignature,
     op_info: qtyping.OpInfo,

ai_edge_quantizer/calibrator_test.py

@@ -234,7 +234,7 @@ class CalibratorTest(googletest.TestCase):
     )
     test_calibrator = calibrator.Calibrator(test_model_path)
     _add_default_int8xint8_integer_recipe(self._recipe_manager)
-    calib_data = test_utils.create_random_normal_input_data(
+    calib_data = tfl_interpreter_utils.create_random_normal_input_data(
         test_model_path, num_samples=4
     )
     test_calibrator.calibrate(calib_data, self._recipe_manager)

ai_edge_quantizer/default_policy.py

@@ -167,7 +167,8 @@ DEFAULT_JSON_POLICY = """
       "SLICE",
       "EMBEDDING_LOOKUP",
       "SUM",
-      "SELECT_V2"
+      "SELECT_V2",
+      "DYNAMIC_UPDATE_SLICE"
     ],
     "static_wi8_ai8": [
       "ADD",
@@ -195,7 +196,8 @@ DEFAULT_JSON_POLICY = """
       "SLICE",
       "EMBEDDING_LOOKUP",
       "SUM",
-      "SELECT_V2"
+      "SELECT_V2",
+      "DYNAMIC_UPDATE_SLICE"
     ],
     "static_wi4_ai8": ["FULLY_CONNECTED", "CONV_2D", "INPUT", "OUTPUT", "EMBEDDING_LOOKUP"],
     "static_wi4_ai16": ["FULLY_CONNECTED", "CONV_2D", "INPUT", "OUTPUT", "EMBEDDING_LOOKUP"],

ai_edge_quantizer/model_validator.py

@@ -160,6 +160,12 @@ class ComparisonResult:
       result.update(signature_comparison_result.intermediate_tensors)
     return result
 
+  def get_model_size_reduction(self) -> tuple[int, float]:
+    """Get the model size reduction in bytes and percentage."""
+    reduced_model_size = len(self._reference_model) - len(self._target_model)
+    reduction_perc = reduced_model_size / len(self._reference_model) * 100
+    return reduced_model_size, reduction_perc
+
   def save(self, save_folder: str, model_name: str) -> None:
     """Saves the model comparison result.
 
@@ -170,8 +176,7 @@ class ComparisonResult:
     Raises:
       RuntimeError: If no quantized model is available.
     """
-    reduced_model_size = len(self._reference_model) - len(self._target_model)
-    reduction_ratio = reduced_model_size / len(self._reference_model) * 100
+    reduced_model_size, reduction_ratio = self.get_model_size_reduction()
     result = {
         'reduced_size_bytes': reduced_model_size,
         'reduced_size_percentage': reduction_ratio,

ai_edge_quantizer/model_validator_test.py

@@ -21,6 +21,7 @@ from tensorflow.python.platform import googletest
 from ai_edge_quantizer import model_validator
 from ai_edge_quantizer.utils import test_utils
 from ai_edge_quantizer.utils import tfl_flatbuffer_utils
+from ai_edge_quantizer.utils import tfl_interpreter_utils
 from ai_edge_quantizer.utils import validation_utils
 
 TEST_DATA_PREFIX_PATH = test_utils.get_path_to_datafile('.')
@@ -194,7 +195,7 @@ class ModelValidatorCompareTest(googletest.TestCase):
         self.target_model_path
     )
     self.signature_key = 'serving_default'  # single signature.
-    self.test_data = test_utils.create_random_normal_input_data(
+    self.test_data = tfl_interpreter_utils.create_random_normal_input_data(
         self.reference_model_path
     )
     self.test_dir = self.create_tempdir()

ai_edge_quantizer/qtyping.py

@@ -60,6 +60,7 @@ class TFLOperationName(str, enum.Enum):
   SLICE = 'SLICE'
   SUM = 'SUM'
   SELECT_V2 = 'SELECT_V2'
+  DYNAMIC_UPDATE_SLICE = 'DYNAMIC_UPDATE_SLICE'
 
 
 class QuantizeMode(enum.Enum):

ai_edge_quantizer/quantizer.py

@@ -28,7 +28,6 @@ from ai_edge_quantizer import model_validator
 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 ai_edge_quantizer.utils import tfl_interpreter_utils
 from ai_edge_quantizer.utils import validation_utils
@@ -325,7 +324,7 @@ class Quantizer:
     """
     if test_data is None:
       # Create test data for all signatures in the model.
-      test_data = test_utils.create_random_normal_input_data(
+      test_data = tfl_interpreter_utils.create_random_normal_input_data(
           self.float_model, num_samples=1
       )
     return model_validator.compare_model(

ai_edge_quantizer/utils/test_utils.py

@@ -18,12 +18,20 @@
 import inspect as _inspect
 import os.path as _os_path
 import sys as _sys
-from typing import Any, Union
 
-import numpy as np
+from absl.testing import parameterized
 
+from ai_edge_quantizer import model_validator
+from ai_edge_quantizer import qtyping
+from ai_edge_quantizer import quantizer
 from ai_edge_quantizer.utils import tfl_interpreter_utils
 
+_ComputePrecision = qtyping.ComputePrecision
+_OpName = qtyping.TFLOperationName
+_TensorQuantConfig = qtyping.TensorQuantizationConfig
+_OpQuantConfig = qtyping.OpQuantizationConfig
+_AlgorithmName = quantizer.AlgorithmName
+
 
 def get_path_to_datafile(path):
   """Get the path to the specified file in the data dependencies.
@@ -46,62 +54,84 @@ def get_path_to_datafile(path):
   return path
 
 
-def create_random_normal_dataset(
-    input_details: dict[str, Any],
-    num_samples: int,
-    random_seed: Union[int, np._typing.ArrayLike],
-) -> list[dict[str, Any]]:
-  """create random dataset following random distribution.
-
-  Args:
-    input_details: list of dict created by
-      tensorflow.lite.interpreter.get_input_details() for generating dataset
-    num_samples: number of input samples to be generated
-    random_seed: random seed to be used for function
-
-  Returns:
-    a list of inputs to the given interpreter, for a single interpreter we may
-    have multiple input tensors so each set of inputs is also represented as
-    list
-  """
-  rng = np.random.default_rng(random_seed)
-  dataset = []
-  for _ in range(num_samples):
-    input_data = {}
-    for arg_name, input_tensor in input_details.items():
-      new_data = rng.normal(size=input_tensor['shape']).astype(
-          input_tensor['dtype']
+class BaseOpTestCase(parameterized.TestCase):
+  """Base class for op-level tests."""
+
+  def quantize_and_validate(
+      self,
+      model_path: str,
+      algorithm_key: _AlgorithmName,
+      op_name: _OpName,
+      op_config: _OpQuantConfig,
+      num_validation_samples: int = 4,
+      error_metric: str = 'mse',
+  ) -> model_validator.ComparisonResult:
+    """Quantizes and validates the given model with the given configurations.
+
+    Args:
+      model_path: The path to the model to be quantized.
+      algorithm_key: The algorithm to be used for quantization.
+      op_name: The name of the operation to be quantized.
+      op_config: The configuration for the operation to be quantized.
+      num_validation_samples: The number of samples to use for validation.
+      error_metric: The error error_metric to use for validation.
+
+    Returns:
+      The comparison result of the validation.
+    """
+    quantizer_instance = quantizer.Quantizer(model_path)
+    quantizer_instance.update_quantization_recipe(
+        algorithm_key=algorithm_key,
+        regex='.*',
+        operation_name=op_name,
+        op_config=op_config,
+    )
+    if quantizer_instance.need_calibration:
+      calibration_data = tfl_interpreter_utils.create_random_normal_input_data(
+          quantizer_instance.float_model, num_samples=num_validation_samples * 8
       )
-      input_data[arg_name] = new_data
-    dataset.append(input_data)
-  return dataset
-
-
-def create_random_normal_input_data(
-    tflite_model: Union[str, bytes],
-    num_samples: int = 4,
-    random_seed: int = 666,
-) -> dict[str, list[dict[str, Any]]]:
-  """create random dataset following random distribution for signature runner.
-
-  Args:
-    tflite_model: TFLite model path or bytearray
-    num_samples: number of input samples to be generated
-    random_seed: random seed to be used for function
-
-  Returns:
-    a list of inputs to the given interpreter, for a single interpreter we may
-    have multiple signatures so each set of inputs is also represented as
-    list
-  """
-  tfl_interpreter = tfl_interpreter_utils.create_tfl_interpreter(tflite_model)
-  signature_defs = tfl_interpreter.get_signature_list()
-  signature_keys = list(signature_defs.keys())
-  test_data = {}
-  for signature_key in signature_keys:
-    signature_runner = tfl_interpreter.get_signature_runner(signature_key)
-    input_details = signature_runner.get_input_details()
-    test_data[signature_key] = create_random_normal_dataset(
-        input_details, num_samples, random_seed
+      calibration_result = quantizer_instance.calibrate(calibration_data)
+      quantization_result = quantizer_instance.quantize(calibration_result)
+    else:
+      quantization_result = quantizer_instance.quantize()
+    test_data = tfl_interpreter_utils.create_random_normal_input_data(
+        quantization_result.quantized_model, num_samples=num_validation_samples
     )
-  return test_data
+    return quantizer_instance.validate(test_data, error_metric)
+
+  def assert_model_size_reduction_above_min_pct(
+      self,
+      validation_result: model_validator.ComparisonResult,
+      min_pct: float,
+  ):
+    """Checks the model size reduction (percentage) against the given expectation."""
+    _, reduction_pct = validation_result.get_model_size_reduction()
+    self.assertGreater(reduction_pct, min_pct)
+
+  def assert_weights_errors_below_tolerance(
+      self,
+      validation_result: model_validator.ComparisonResult,
+      weight_tolerance: float,
+  ):
+    """Checks the weight tensors' numerical behavior against the given tolerance."""
+    self.assertNotEmpty(validation_result.available_signature_keys())
+    for signature_key in validation_result.available_signature_keys():
+      signature_result = validation_result.get_signature_comparison_result(
+          signature_key
+      )
+      for result in signature_result.constant_tensors.values():
+        self.assertLess(result, weight_tolerance)
+
+  def assert_output_errors_below_tolerance(
+      self,
+      validation_result: model_validator.ComparisonResult,
+      output_tolerance: float,
+  ):
+    """Checks the output tensor numerical behavior against the given tolerance."""
+    self.assertNotEmpty(validation_result.available_signature_keys())
+    for signature_key in validation_result.available_signature_keys():
+      signature_result = validation_result.get_signature_comparison_result(
+          signature_key
+      )
+      for result in signature_result.output_tensors.values():
+        self.assertLess(result, output_tolerance)

ai_edge_quantizer/utils/tfl_flatbuffer_utils.py

@@ -62,6 +62,9 @@ TFL_OP_NAME_TO_CODE = immutabledict.immutabledict({
     _TFLOpName.SLICE: schema_py_generated.BuiltinOperator.SLICE,
     _TFLOpName.SUM: schema_py_generated.BuiltinOperator.SUM,
     _TFLOpName.SELECT_V2: schema_py_generated.BuiltinOperator.SELECT_V2,
+    _TFLOpName.DYNAMIC_UPDATE_SLICE: (
+        schema_py_generated.BuiltinOperator.DYNAMIC_UPDATE_SLICE
+    ),
 })
 
 TFL_OP_CODE_TO_NAME = immutabledict.immutabledict(

ai_edge_quantizer/utils/tfl_interpreter_utils.py

@@ -315,3 +315,62 @@ def get_signature_main_subgraph_index(
   """
   signature_runner = tflite_interpreter.get_signature_runner(signature_key)
   return signature_runner._subgraph_index  # pylint:disable=protected-access
+
+
+def create_random_normal_dataset(
+    input_details: dict[str, Any],
+    num_samples: int,
+    random_seed: Union[int, np._typing.ArrayLike],
+) -> list[dict[str, Any]]:
+  """Creates a random normal dataset for given input details.
+
+  Args:
+    input_details: A dictionary of input details.
+    num_samples: The number of samples to generate.
+    random_seed: The random seed to use.
+
+  Returns:
+    A list of dictionaries, each containing a sample of input data (for all
+    signatures).
+  """
+  rng = np.random.default_rng(random_seed)
+  dataset = []
+  for _ in range(num_samples):
+    input_data = {}
+    for arg_name, input_tensor in input_details.items():
+      new_data = rng.normal(size=input_tensor["shape"]).astype(
+          input_tensor["dtype"]
+      )
+      input_data[arg_name] = new_data
+    dataset.append(input_data)
+  return dataset
+
+
+def create_random_normal_input_data(
+    tflite_model: Union[str, bytes],
+    num_samples: int = 4,
+    random_seed: int = 666,
+) -> dict[str, list[dict[str, Any]]]:
+  """create random dataset following random distribution for signature runner.
+
+  Args:
+    tflite_model: TFLite model path or bytearray
+    num_samples: number of input samples to be generated
+    random_seed: random seed to be used for function
+
+  Returns:
+    a list of inputs to the given interpreter, for a single interpreter we may
+    have multiple signatures so each set of inputs is also represented as
+    list
+  """
+  tfl_interpreter = create_tfl_interpreter(tflite_model)
+  signature_defs = tfl_interpreter.get_signature_list()
+  signature_keys = list(signature_defs.keys())
+  test_data = {}
+  for signature_key in signature_keys:
+    signature_runner = tfl_interpreter.get_signature_runner(signature_key)
+    input_details = signature_runner.get_input_details()
+    test_data[signature_key] = create_random_normal_dataset(
+        input_details, num_samples, random_seed
+    )
+  return test_data

{ai_edge_quantizer_nightly-0.0.1.dev20250304.dist-info → ai_edge_quantizer_nightly-0.0.1.dev20250306.dist-info}/METADATA

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

@@ -1,19 +1,19 @@
 ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
-ai_edge_quantizer/algorithm_manager.py,sha256=qjpdEei5l-k5wgGDnelMGVDAYb7K7z8Nn9FIuZBWPA0,7534
+ai_edge_quantizer/algorithm_manager.py,sha256=4PPqKQcOLDsrY_LhyPvTQsSfH_fpuBmKzz3Uins1UK4,7637
 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_test.py,sha256=hQk61YUvw1X02CDVAddm2n6Dnyk9GWoDgSpO6nuSJiY,11889
+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=aDWQO00AxTCpciqPavsGBsgC_q_eN75D9ZbNwET4Nko,9119
+ai_edge_quantizer/default_policy.py,sha256=CgArJLygD3eJ2g9ur-i1M9DLb3Tb8yy3hiJfyeikixA,9179
 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=oZk0b1qGczaEm5erJFm4SbwadDnl7DFhC0bXuxwVgps,12787
-ai_edge_quantizer/model_validator_test.py,sha256=ctvVmMHvnmFbkG4o8Jaa6kXXRrGHzhYpNylgLSmOboA,12951
+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_test.py,sha256=d9JwR-yxNJgg1SW-m8sFFPkIRdhgsDwMpVKsBQFL0gg,37658
-ai_edge_quantizer/qtyping.py,sha256=ekmcJXYzBbdJsaQcj6LtcdiuJoU3sKqaUTAIFBQ9oqc,15092
-ai_edge_quantizer/quantizer.py,sha256=Gny7WLuRibiIuDtcRn_g8RCD-zAm_fuDG7WmGq5dRx8,13238
+ai_edge_quantizer/qtyping.py,sha256=qeSxsbU0aEzBMgjvM4a4iYWx1xT7L5Sk5ZyON7xJWWU,15140
+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
@@ -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=s64eDDH9bmRWy6Bl1peHnhGewLnFJjvnhYOdjo1zYOA,22625
 ai_edge_quantizer/algorithms/uniform_quantize/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=wPZevOuowJczG9t4Gynzv7tIeH6zhOnaKPsfr2K_fsk,21259
+ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=l3wJXoyXJXULeSEx3_BzbtIxLzotziT1mQembF9A1RE,21877
 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
@@ -53,15 +53,15 @@ ai_edge_quantizer/transformations/transformation_utils_test.py,sha256=ks81nNvruO
 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=95BDAdjE4Zvd6JZ90fG8FE3wKWE-Lu0ZIE3hQ1B6adI,3616
-ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=F6_AkCSv35FAhJX2qel8VTARhGOVwaeo7_mqRZygrpA,10126
+ai_edge_quantizer/utils/test_utils.py,sha256=gmq3QeyVuMAgYuGp_uZ2Ei0TOCDqW2jD2GcfgcCX9FA,5183
+ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=pI4JWq_rhp1tRWwNSFMzbWx-3YEQWQir-bM6S88WKIw,10237
 ai_edge_quantizer/utils/tfl_flatbuffer_utils_test.py,sha256=AbyDxoM62k4ojD8gPdkWo--xe5hlX3t0kobQSA80kuk,7740
-ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=SM8H4i7Jq_nfdsJpImopHndNCJznlLr-6ptUbp5bVWA,10558
+ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=ZI16i25bAOpnJUBgRg38EH2CuZ55wxyHFScM12RsOwc,12487
 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.dev20250304.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.0.1.dev20250304.dist-info/METADATA,sha256=-hyaPuaelixtYTuwKAXoZuAFu0UMFJFII2addVyVMPE,1528
-ai_edge_quantizer_nightly-0.0.1.dev20250304.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ai_edge_quantizer_nightly-0.0.1.dev20250304.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.0.1.dev20250304.dist-info/RECORD,,
+ai_edge_quantizer_nightly-0.0.1.dev20250306.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.0.1.dev20250306.dist-info/METADATA,sha256=yPtUua8FBDeyCPVB9HTdKU7TYhCXd4HnSEj6NYMRwDQ,1528
+ai_edge_quantizer_nightly-0.0.1.dev20250306.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+ai_edge_quantizer_nightly-0.0.1.dev20250306.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.0.1.dev20250306.dist-info/RECORD,,