ai-edge-quantizer-nightly 0.0.1.dev20250302__py3-none-any.whl → 0.5.0.dev20260103__py3-none-any.whl

ai_edge_quantizer/utils/tfl_interpreter_utils.py

@@ -17,21 +17,25 @@
 
 from typing import Any, Optional, Union
 
+import ml_dtypes
 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"
 
+_Numeric = Union[int, float]
+
 
 def create_tfl_interpreter(
     tflite_model: Union[str, bytes],
     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.
 
@@ -40,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:
@@ -56,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()
@@ -216,8 +222,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
@@ -315,3 +323,128 @@ 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(
+    rng: np.random.Generator,
+    shape: tuple[int, ...],
+    dtype: np.dtype,
+) -> dict[str, Any]:
+  """Creates a random normal dataset sample for given input details."""
+  return rng.normal(size=shape).astype(dtype)
+
+
+def _create_random_uniform(
+    rng: np.random.Generator,
+    shape: tuple[int, ...],
+    dtype: np.dtype,
+    min_value: float = 0.0,
+    max_value: float = 1.0,
+) -> dict[str, Any]:
+  """Creates a random uniform dataset sample for given input details."""
+  return rng.uniform(min_value, max_value, size=shape).astype(dtype)
+
+
+def _create_random_integers(
+    rng: np.random.Generator,
+    shape: tuple[int, ...],
+    dtype: np.dtype,
+    min_value: int = 0,
+    max_value: int = 1024,
+) -> dict[str, Any]:
+  """Creates a random integer dataset sample for given input details."""
+  return rng.integers(min_value, max_value, size=shape, dtype=dtype)
+
+
+def _create_random_bool(
+    rng: np.random.Generator,
+    shape: tuple[int, ...],
+    dtype: np.dtype,
+) -> dict[str, Any]:
+  """Creates a random bool dataset sample for given input details."""
+  return rng.choice([True, False], size=shape, replace=True).astype(dtype)
+
+
+def create_random_dataset(
+    input_details: dict[str, Any],
+    num_samples: int,
+    random_seed: Union[int, np._typing.ArrayLike],
+    min_max_range: Optional[tuple[_Numeric, _Numeric]] = None,
+) -> 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.
+    min_max_range: The min and max of the input range.
+
+  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():
+      dtype = input_tensor["dtype"]
+      shape = input_tensor["shape"]
+      if dtype in (np.int32, np.int64):
+        if min_max_range is None:
+          new_data = _create_random_integers(rng, shape, dtype)
+        else:
+          min_value, max_value = min_max_range
+          new_data = _create_random_integers(
+              rng, shape, dtype, min_value, max_value
+          )
+      elif dtype in (np.float32, ml_dtypes.bfloat16):
+        if min_max_range is None:
+          new_data = _create_random_normal(rng, shape, dtype)
+        else:
+          min_value, max_value = min_max_range
+          new_data = _create_random_uniform(
+              rng, shape, dtype, min_value, max_value
+          )
+      elif dtype == np.bool:
+        new_data = _create_random_bool(rng, shape, dtype)
+      else:
+        raise ValueError(f"Unsupported dtype: {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,
+    min_max_range: Optional[tuple[_Numeric, _Numeric]] = None,
+) -> dict[str, list[dict[str, Any]]]:
+  """Creates a random normal dataset for a 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.
+    min_max_range: The min and max of the input range.
+
+  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_dataset(
+        input_details,
+        num_samples,
+        random_seed,
+        min_max_range,
+    )
+  return test_data

ai_edge_quantizer/utils/tfl_interpreter_utils_test.py

@@ -19,7 +19,6 @@ from tensorflow.python.platform import googletest
 from ai_edge_quantizer.utils import test_utils
 from ai_edge_quantizer.utils import tfl_interpreter_utils
 
-
 TEST_DATA_PREFIX_PATH = test_utils.get_path_to_datafile("../tests/models")
 
 
@@ -91,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
@@ -159,7 +168,6 @@ class TflUtilsQuantizedModelTest(googletest.TestCase):
     signature_output = tfl_interpreter_utils.invoke_interpreter_signature(
         tfl_interpreter, self._signature_input_data
     )
-    print(signature_output)
     self.assertEqual(tuple(signature_output["dense_1"].shape), (1, 10))
 
     # Assert the input data is not modified in-place b/353340272.
@@ -328,5 +336,24 @@ class TflUtilsMultiSignatureModelTest(googletest.TestCase):
     self.assertEqual(multiply_output_content, [20.0])
 
 
+class TflUtilsIntegerInputModelTest(googletest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    np.random.seed(0)
+    self._test_model_path = os.path.join(
+        TEST_DATA_PREFIX_PATH, "toy_model_with_kv_cache_multi_signature.tflite"
+    )
+
+  def test_random_integer_input_data(self):
+    test_data = tfl_interpreter_utils.create_random_normal_input_data(
+        self._test_model_path
+    )
+    self.assertEqual(test_data["signature_1"][0]["cache_0"].dtype, np.float32)
+    self.assertEqual(test_data["signature_1"][0]["cache_1"].dtype, np.float32)
+    self.assertEqual(test_data["signature_1"][0]["positions"].dtype, np.int32)
+    self.assertEqual(test_data["signature_1"][0]["tokens"].dtype, np.int32)
+
+
 if __name__ == "__main__":
   googletest.main()

ai_edge_quantizer/utils/validation_utils.py

@@ -32,12 +32,18 @@ def get_validation_func(
     a validation function
 
   Raises:
-    Value error if the function name is not supported
+    ValueError: if the function name is not supported
   """
   if func_name == "mse":
     return mean_squared_difference
   elif func_name == "median_diff_ratio":
     return median_diff_ratio
+  elif func_name == "cosine_similarity":
+    return cosine_similarity
+  elif func_name == "kl_divergence":
+    return kl_divergence
+  elif func_name == "snr":
+    return signal_to_noise_ratio
   else:
     raise ValueError(f"Validation function {func_name} not supported")
 
@@ -58,7 +64,7 @@ def mean_squared_difference(
     a float value representing the MSD between data1 & 2
 
   Raises:
-    Value error if the two inputs don't have the same number of elements
+    ValueError: if the two inputs don't have the same number of elements
   """
   data1, data2 = _preprocess_same_size_arrays(data1, data2)
   # special handling for tensor of size 0
@@ -87,7 +93,7 @@ def median_diff_ratio(
     a float value representing the median diff ratio between data1 & 2
 
   Raises:
-    Value error if the two inputs don't have the same number of elements
+    ValueError: if the two inputs don't have the same number of elements
   """
   data1, data2 = _preprocess_same_size_arrays(data1, data2)
   # special handling for tensor of size 0
@@ -99,6 +105,110 @@ def median_diff_ratio(
   return median_ratio
 
 
+def cosine_similarity(
+    data1: np._typing.ArrayLike,
+    data2: np._typing.ArrayLike,
+) -> float:
+  """Calculates the cosine similarity between data1 & data2.
+
+  ref: https://en.wikipedia.org/wiki/Cosine_similarity
+
+  Args:
+    data1: input data to be used for comparison
+    data2: input data to be used for comparison, data1 & 2 must be of the same
+      shape
+
+  Returns:
+    a float value representing the cosine similarity between data1 & 2
+
+  Raises:
+    ValueError: if the two inputs don't have the same number of elements
+  """
+  data1, data2 = _preprocess_same_size_arrays(data1, data2)
+  # special handling for tensor of size 0
+  if data1.size == 0:
+    return float(0)
+  norm_data1 = np.linalg.norm(data1)
+  norm_data2 = np.linalg.norm(data2)
+  # special handling for tensor of length 0
+  if norm_data1 == 0 and norm_data2 == 0:
+    return 1.0
+  if norm_data1 == 0 or norm_data2 == 0:
+    return 0.0
+  return np.dot(data1, data2) / (norm_data1 * norm_data2)
+
+
+def kl_divergence(
+    data1: np._typing.ArrayLike,
+    data2: np._typing.ArrayLike,
+    epsilon: float = 1e-9,
+) -> float:
+  """Calculates the KL divergence between data1 & data2.
+
+  KL(data2 || data1) = sum(data2 * log(data2 / data1)).
+  data2 is treated as the true distribution P, and data1 as the
+  approximated distribution Q.
+  Non-positive values in data1 and data2 are clipped to 0 before
+  KL divergence calculation. Epsilon is added to avoid log(0) and
+  division by zero.
+
+  Args:
+    data1: input data to be used for comparison (distribution Q)
+    data2: input data to be used for comparison (distribution P), data1 & 2 must
+      be of the same shape
+    epsilon: small value to avoid log(0) and division by zero.
+
+  Returns:
+    A float value representing the KL divergence between data1 & 2.
+
+  Raises:
+    ValueError: if the two inputs don't have the same number of elements.
+  """
+  data1, data2 = _preprocess_same_size_arrays(data1, data2)
+  # special handling for tensor of size 0
+  if data1.size == 0:
+    return float(0)
+
+  p = np.maximum(0, data2)
+  q = np.maximum(0, data1)
+
+  return float(np.sum(p * np.log((p + epsilon) / (q + epsilon))))
+
+
+def signal_to_noise_ratio(
+    noisy_signal: np._typing.ArrayLike,
+    signal: np._typing.ArrayLike,
+    epsilon: float = 1e-9,
+) -> float:
+  """Calculates the signal to noise ratio between noisy_signal & signal.
+
+  SNR = P_signal / P_noise, where signal is treated as the clean signal and
+  noisy_signal-signal is treated as the noise samples.
+  P_signal = mean(signal^2)
+  P_noise = mean((noisy_signal-signal)^2) = mse(noisy_signal, signal)
+
+  Args:
+    noisy_signal: Input data to be used for comparison (e.g. noisy signal).
+    signal: Input data to be used for comparison (e.g. clean signal),
+      noisy_signal & signal must be of the same shape.
+    epsilon: Small value to avoid division by zero.
+
+  Returns:
+    A float value representing the SNR between noisy_signal & signal.
+
+  Raises:
+    ValueError: If the two inputs don't have the same number of elements.
+  """
+  noisy_signal, signal = _preprocess_same_size_arrays(noisy_signal, signal)
+  if signal.size == 0:
+    return float(0)
+
+  mse = mean_squared_difference(noisy_signal, signal)
+  signal_power = float(np.square(signal).mean())
+  snr = signal_power / (mse + epsilon)
+  return snr
+
+
 def _preprocess_same_size_arrays(
     data1: np._typing.ArrayLike, data2: np._typing.ArrayLike
 ) -> Tuple[np.ndarray, np.ndarray]:
@@ -113,7 +223,7 @@ def _preprocess_same_size_arrays(
     a tuple of the preprocessed data1 & 2
 
   Raises:
-    Value error if the two inputs don't have the same number of elements
+    ValueError: if the two inputs don't have the same number of elements
   """
   data1 = np.array(data1, dtype=np.float32).flatten()
   data2 = np.array(data2, dtype=np.float32).flatten()

ai_edge_quantizer/utils/validation_utils_test.py

@@ -82,6 +82,86 @@ class ValidationUtilTest(googletest.TestCase):
     result = validation_utils.median_diff_ratio(data1, data2)
     self.assertEqual(result, 0)
 
+  def test_cosine_similarity(self):
+    data1 = [1, 2, 3]
+    data2 = [1, 2, 3]
+    result = validation_utils.cosine_similarity(data1, data2)
+    self.assertAlmostEqual(result, 1.0, 6)
+
+  def test_cosine_similarity_perpendicular(self):
+    data1 = [1, 0, 0]
+    data2 = [0, 1, 0]
+    result = validation_utils.cosine_similarity(data1, data2)
+    self.assertAlmostEqual(result, 0.0, 6)
+
+  def test_cosine_similarity_multidim(self):
+    data1 = [[1, 2], [4, 5]]
+    data2 = [[1, 3], [2, 2]]
+    result = validation_utils.cosine_similarity(data1, data2)
+    self.assertAlmostEqual(result, 0.86881, 6)
+
+  def test_cosine_similarity_0d(self):
+    data1 = []
+    data2 = []
+    result = validation_utils.cosine_similarity(data1, data2)
+    self.assertEqual(result, 0)
+
+  def test_kl_divergence(self):
+    data1 = [0.5, 0.5]
+    data2 = [0.1, 0.9]
+    result = validation_utils.kl_divergence(data1, data2)
+    self.assertAlmostEqual(result, 0.36808, 4)
+
+  def test_kl_divergence_zero_in_q(self):
+    data1 = [0, 1]
+    data2 = [1, 0]
+    result = validation_utils.kl_divergence(data1, data2)
+    self.assertAlmostEqual(result, 20.7232658, 4)
+
+  def test_kl_divergence_negative_values(self):
+    data1 = [-1, 1]
+    data2 = [1, -1]
+    result = validation_utils.kl_divergence(data1, data2)
+    self.assertAlmostEqual(result, 20.7232658, 4)
+
+  def test_kl_divergence_0d(self):
+    data1 = []
+    data2 = []
+    result = validation_utils.kl_divergence(data1, data2)
+    self.assertEqual(result, 0)
+
+  def test_get_validation_func_kl_divergence(self):
+    func = validation_utils.get_validation_func("kl_divergence")
+    self.assertEqual(func, validation_utils.kl_divergence)
+
+  def test_signal_to_noise_ratio_0d(self):
+    data1 = []
+    data2 = []
+    result = validation_utils.signal_to_noise_ratio(data1, data2)
+    self.assertEqual(result, 0)
+
+  def test_signal_to_noise_ratio_identical(self):
+    data1 = [1, 2, 3]
+    data2 = [1, 2, 3]
+    result = validation_utils.signal_to_noise_ratio(data1, data2)
+    self.assertGreater(result, 1e8)  # mse=0, so snr should be large
+
+  def test_signal_to_noise_ratio_with_noise(self):
+    data1 = [2, 3, 4]
+    data2 = [1, 2, 3]
+    result = validation_utils.signal_to_noise_ratio(data1, data2)
+    self.assertAlmostEqual(result, 14 / 3, places=5)
+
+  def test_signal_to_noise_ratio_simple(self):
+    data1 = [1, 1]
+    data2 = [1, 0]
+    result = validation_utils.signal_to_noise_ratio(data1, data2)
+    self.assertAlmostEqual(result, 1.0, places=5)
+
+  def test_get_validation_func_snr(self):
+    func = validation_utils.get_validation_func("snr")
+    self.assertEqual(func, validation_utils.signal_to_noise_ratio)
+
 
 if __name__ == "__main__":
   googletest.main()

{ai_edge_quantizer_nightly-0.0.1.dev20250302.dist-info → ai_edge_quantizer_nightly-0.5.0.dev20260103.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ai-edge-quantizer-nightly
-Version: 0.0.1.dev20250302
+Version: 0.5.0.dev20260103
 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,10 +24,20 @@ 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>=2.17.0.dev20240509
+Requires-Dist: ml_dtypes
 Requires-Dist: ai-edge-litert-nightly
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 It aims to facilitate advanced users to strive for optimal performance on
 resource demanding models (e.g., GenAI models).

ai_edge_quantizer_nightly-0.5.0.dev20260103.dist-info/RECORD

@@ -0,0 +1,81 @@
+ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
+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=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=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=-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=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=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
+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=EqIHGEZ1LgUrTN7zf880RuAzEv3Qy7kgh5ivObJGHSo,22646
+ai_edge_quantizer/algorithms/uniform_quantize/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
+ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=_ItPnd2TXj95QimjiPaJOKcyfW_C5emIougygNTaZxA,42072
+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
+ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation.py,sha256=qxt9CPDcidVWIxp5nSWPN2hKKj1XZcsOOLBd2SYIvW0,14572
+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=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/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
+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=TvTHbm24IiICNkWOlvR2UpJKMU-88puNFycDYc0_ehQ,1774
+ai_edge_quantizer/transformations/duplicate_buffer_test.py,sha256=YYWl3Q5WF60s8T8pLzzA8TCSxz-i7dqc03dJt1LtMw4,3880
+ai_edge_quantizer/transformations/duplicate_tensor.py,sha256=WKhf2LIAL0MnZe88b6942A37lvHXe1cFjUDqE5VNmvU,2490
+ai_edge_quantizer/transformations/duplicate_tensor_test.py,sha256=s-RqSxNBMfVJyCunXz2eb7-KA6UiBmbOmL7phLslENQ,5056
+ai_edge_quantizer/transformations/insert_decomposed_hadamard_rotation.py,sha256=kBQQZ0VKUsV8hId3_a4K-812wNrZHU4LK2c1Rt_D_XA,11084
+ai_edge_quantizer/transformations/insert_decomposed_hadamard_rotation_test.py,sha256=Z9Nr5e5aEeEMahhhizFyOkAMEXkEg1EKYZ_bGb5Vbvw,8993
+ai_edge_quantizer/transformations/insert_hadamard_rotation.py,sha256=5D5WwrJCE6hQoANbMwa6YGBbjcG5HcL_rkkoXIAIW9w,6883
+ai_edge_quantizer/transformations/insert_hadamard_rotation_test.py,sha256=iV1p3nZfHUATV2YRoBOYurnu3pLy8n3aFppLWGQOPdA,7268
+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=VGTVpZWla9R-LPfhTzH1NVAp2soOqDF_duIm8ez_z3Y,7264
+ai_edge_quantizer/transformations/quantize_tensor_test.py,sha256=CD7OboBcIQxQY8OaRd5ISC1JcwQW726P_vneY4LKVpA,9117
+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=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=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=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.dev20260103.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.5.0.dev20260103.dist-info/METADATA,sha256=gJG1WQM6zOnsWl8Fp3axH3YydN3szFTS6qZ05biDrXw,1729
+ai_edge_quantizer_nightly-0.5.0.dev20260103.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+ai_edge_quantizer_nightly-0.5.0.dev20260103.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.5.0.dev20260103.dist-info/RECORD,,

{ai_edge_quantizer_nightly-0.0.1.dev20250302.dist-info → ai_edge_quantizer_nightly-0.5.0.dev20260103.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any