ai-edge-quantizer-nightly 0.3.0.dev20250814__py3-none-any.whl → 0.3.0.dev20250816__py3-none-any.whl

ai_edge_quantizer/algorithm_manager.py

@@ -102,6 +102,7 @@ MIN_MAX_OP_NAME_MATERIALIZE_FUNC_DICT = {
     _TFLOpName.LOGISTIC: common_quantize.materialize_softmax_and_logistic,
     _TFLOpName.SLICE: common_quantize.materialize_slice,
     _TFLOpName.SUM: common_quantize.materialize_sum,
+    _TFLOpName.SELECT: common_quantize.materialize_select,
     _TFLOpName.SELECT_V2: common_quantize.materialize_select_v2,
     _TFLOpName.DYNAMIC_UPDATE_SLICE: (
         common_quantize.materialize_dynamic_update_slice
@@ -250,6 +251,7 @@ _OCTAV_OP_NAME_MATERIALIZE_FUNC_DICT = immutabledict({
     _TFLOpName.LOGISTIC: common_quantize.materialize_softmax_and_logistic,
     _TFLOpName.SLICE: common_quantize.materialize_slice,
     _TFLOpName.SUM: common_quantize.materialize_sum,
+    _TFLOpName.SELECT: common_quantize.materialize_select,
     _TFLOpName.SELECT_V2: common_quantize.materialize_select_v2,
     _TFLOpName.DYNAMIC_UPDATE_SLICE: (
         common_quantize.materialize_dynamic_update_slice

ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py

@@ -371,6 +371,25 @@ def materialize_slice(
   )
 
 
+def materialize_select(
+    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.select."""
+  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=[
+          0,
+      ],  # Condition tensor does not need to be quantized.
+  )
+
+
 def materialize_select_v2(
     get_tensor_quant_params_fn: qtyping.GetTensorQuantParamsFuncSignature,
     op_info: qtyping.OpInfo,

ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor.py

@@ -387,22 +387,37 @@ def tensor_zp_scale_from_min_max(
   )
   qmin, qmax = get_quantized_range(qtype)
   min_bound = 1e-4  # 1e-6 precision for int8 and 1e-8 for int16.
+  pos_clipping_values = None if clipping_values is None else clipping_values
+  neg_clipping_values = None if clipping_values is None else -clipping_values
 
   if granularity == qtyping.QuantGranularity.BLOCKWISE:
-    # Blockwise quantization uses float16 scale, with 7 bit mantissa,
-    # so the maximum representable value is 65280.
-    float16_max = np.broadcast_to(np.array(65280), min_value.shape)
-    clipping_values = (
+    # Blockwise quantization uses float16 scale,
+    # with 7 bit mantissa, so the maximum scale value is 65280 and maximum
+    # representable range is [-65280 * (2 ** num_bits),
+    # 65280 * (2 ** num_bits - 1)].
+    # Note that we have one extra value on the negative side.
+    float16_max = np.broadcast_to(
+        np.array(65280) * (2**num_bits - 1), max_value.shape
+    )
+    float16_min = np.broadcast_to(
+        np.array(-65280) * (2**num_bits), min_value.shape
+    )
+    pos_clipping_values = (
         float16_max
-        if clipping_values is None
-        else np.minimum(clipping_values, float16_max)
+        if pos_clipping_values is None
+        else np.minimum(pos_clipping_values, float16_max)
+    )
+    neg_clipping_values = (
+        float16_min
+        if neg_clipping_values is None
+        else np.maximum(neg_clipping_values, float16_min)
     )
 
   if symmetric:
     bound = np.maximum(np.abs(min_value), np.abs(max_value))
     bound = np.maximum(bound, min_bound)
     if clipping_values is not None:
-      bound = np.clip(bound, -clipping_values, clipping_values)
+      bound = np.clip(bound, neg_clipping_values, pos_clipping_values)
     if not qtype.signed:
       half_q = (qmax - 1) / 2
       scale = bound / half_q

ai_edge_quantizer/calibrator_test.py

@@ -302,7 +302,7 @@ class CalibratorToyGemma2Test(googletest.TestCase):
         self._toy_gemma2_calibration_dataset,
         model_recipe_manager=recipe_mngr,
     )
-    self.assertLen(calib.get_model_qsvs(), 288)
+    self.assertLen(calib.get_model_qsvs(), 290)
 
 
 if __name__ == "__main__":

ai_edge_quantizer/default_policy.py

@@ -180,6 +180,7 @@ DEFAULT_JSON_POLICY = """
       "SLICE",
       "EMBEDDING_LOOKUP",
       "SUM",
+      "SELECT",
       "SELECT_V2",
       "DYNAMIC_UPDATE_SLICE",
       "SELECT_V2",
@@ -222,6 +223,7 @@ DEFAULT_JSON_POLICY = """
       "SLICE",
       "EMBEDDING_LOOKUP",
       "SUM",
+      "SELECT",
       "SELECT_V2",
       "DYNAMIC_UPDATE_SLICE",
       "SELECT_V2",

ai_edge_quantizer/qtyping.py

@@ -59,6 +59,7 @@ class TFLOperationName(str, enum.Enum):
   LOGISTIC = 'LOGISTIC'
   SLICE = 'SLICE'
   SUM = 'SUM'
+  SELECT = 'SELECT'
   SELECT_V2 = 'SELECT_V2'
   DYNAMIC_UPDATE_SLICE = 'DYNAMIC_UPDATE_SLICE'
   STABLEHLO_COMPOSITE = 'STABLEHLO_COMPOSITE'

ai_edge_quantizer/quantizer.py

@@ -35,6 +35,7 @@ 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
 
+
 # Expose algorithm names to users.
 AlgorithmName = algorithm_manager.AlgorithmName
 
@@ -220,6 +221,109 @@ class Quantizer:
         regex, operation_name, op_config, algorithm_key
     )
 
+  def add_dynamic_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      num_bits: int,
+      granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a dynamic quantization configuration to the recipe.
+
+    During dynamic quantization, activations are not processed by AEQ and
+    remain in float format. The runtime kernel is expected to quantize these
+    activations on-the-fly, as indicated by compute_precision=Integer and
+    explicit_dequantize=False.
+
+    The model quality may suffer due to the on-the-fly quantization. If quality
+    is a concern, consider using weight-only
+    quantization.
+
+    Args:
+      regex: Regular expression for layer name (op's output tensor name)
+        matching.
+      operation_name: Target TFLite operation.
+      num_bits: Number of bits for quantization.
+      granularity: Granularity of quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    self._recipe_manager.add_dynamic_config(
+        regex, operation_name, num_bits, granularity, algorithm_key
+    )
+
+  def add_weight_only_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      num_bits: int,
+      granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a weight only quantization configuration to the recipe.
+
+    In weight-only quantization, weights are quantized, but the actual operation
+    (op) computation remains in float. The quantized weight is explicitly
+    dequantized before being fed into the op. This is achieved by inserting a
+    dequantize op between the quantized weight and the consuming op. To enable
+    this, both compute_precision will be set to Float and explicit_dequantize to
+    True.
+
+    Weight-only quantization is useful for reducing model size but may
+    not decrease latency due to float computation. However, quantized model
+    generally has better quality than other quantization options (e.g., dynamic
+    range quantization) due to no loss of precision on activations. If latency
+    is a concern, consider using dynamic quantization.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      num_bits: Number of bits for quantization.
+      granularity: Granularity of quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    self._recipe_manager.add_weight_only_config(
+        regex, operation_name, num_bits, granularity, algorithm_key
+    )
+
+  def add_static_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      activation_num_bits: int,
+      weight_num_bits: int,
+      weight_granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a static quantization configuration to the recipe.
+
+    In static quantization, both weights and activations are quantized. This
+    requires a calibration step to determine the quantization parameters (e.g.,
+    min/max ranges) for activations. The quantized model uses integer arithmetic
+    for computations, which can lead to significant latency reductions.
+
+    However, calibration is needed to determine the quantization parameters for
+    activations, which requires sample data and may lead to quality loss. If
+    there is no hardware requirement for full integer quantization, consider
+    using dynamic quantization for simplicity.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      activation_num_bits: Number of bits for activation quantization.
+      weight_num_bits: Number of bits for weight quantization.
+      weight_granularity: Granularity of weight quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    self._recipe_manager.add_static_config(
+        regex,
+        operation_name,
+        activation_num_bits,
+        weight_num_bits,
+        weight_granularity,
+        algorithm_key,
+    )
+
   @property
   def need_calibration(self) -> bool:
     """Checks if the current recipe needs calibration."""

ai_edge_quantizer/quantizer_test.py

@@ -92,6 +92,76 @@ class QuantizerTest(parameterized.TestCase):
         new_op_config.compute_precision,
     )
 
+  def test_add_dynamic_config_succeeds(self):
+    self._quantizer.load_quantization_recipe(self._test_recipe_path)
+    scope_regex = '.*/Dense/.*'
+    self._quantizer.add_dynamic_config(
+        regex=scope_regex,
+        operation_name=qtyping.TFLOperationName.FULLY_CONNECTED,
+        num_bits=8,
+    )
+    updated_recipe = self._quantizer.get_quantization_recipe()
+    self.assertLen(updated_recipe, 2)
+
+    added_config = updated_recipe[-1]
+    self.assertEqual(added_config['regex'], scope_regex)
+    self.assertEqual(
+        added_config['op_config']['compute_precision'],
+        qtyping.ComputePrecision.INTEGER,
+    )
+    self.assertFalse(added_config['op_config']['explicit_dequantize'])
+    self.assertEqual(
+        added_config['op_config']['weight_tensor_config']['num_bits'], 8
+    )
+
+  def test_add_weight_only_config_succeeds(self):
+    self._quantizer.load_quantization_recipe(self._test_recipe_path)
+    scope_regex = '.*/Dense/.*'
+    self._quantizer.add_weight_only_config(
+        regex=scope_regex,
+        operation_name=qtyping.TFLOperationName.FULLY_CONNECTED,
+        num_bits=4,
+    )
+    updated_recipe = self._quantizer.get_quantization_recipe()
+    self.assertLen(updated_recipe, 2)
+
+    added_config = updated_recipe[-1]
+    self.assertEqual(added_config['regex'], scope_regex)
+    self.assertEqual(
+        added_config['op_config']['compute_precision'],
+        qtyping.ComputePrecision.FLOAT,
+    )
+    self.assertTrue(added_config['op_config']['explicit_dequantize'])
+    self.assertEqual(
+        added_config['op_config']['weight_tensor_config']['num_bits'], 4
+    )
+
+  def test_add_static_config_succeeds(self):
+    self._quantizer.load_quantization_recipe(self._test_recipe_path)
+    scope_regex = '.*/Dense/.*'
+    self._quantizer.add_static_config(
+        regex=scope_regex,
+        operation_name=qtyping.TFLOperationName.FULLY_CONNECTED,
+        activation_num_bits=8,
+        weight_num_bits=4,
+    )
+    updated_recipe = self._quantizer.get_quantization_recipe()
+    self.assertLen(updated_recipe, 2)
+
+    added_config = updated_recipe[-1]
+    self.assertEqual(added_config['regex'], scope_regex)
+    self.assertEqual(
+        added_config['op_config']['compute_precision'],
+        qtyping.ComputePrecision.INTEGER,
+    )
+    self.assertFalse(added_config['op_config']['explicit_dequantize'])
+    self.assertEqual(
+        added_config['op_config']['activation_tensor_config']['num_bits'], 8
+    )
+    self.assertEqual(
+        added_config['op_config']['weight_tensor_config']['num_bits'], 4
+    )
+
   def test_load_quantization_recipe_succeeds(self):
     qt = quantizer.Quantizer(self._test_model_path, None)
     qt.load_quantization_recipe(self._test_recipe_path)

ai_edge_quantizer/recipe.py

@@ -15,51 +15,163 @@
 
 """Quantization recipe module."""
 
+from ai_edge_quantizer import algorithm_manager
+from ai_edge_quantizer import qtyping
+from ai_edge_quantizer import recipe_manager
 
-def dynamic_wi8_afp32():
-  """Returns a dynamic quantization recipe with int8 weights and float32 activation."""
-  return [
-      dict({
-          'regex': '.*',
-          'operation': '*',
-          'algorithm_key': 'min_max_uniform_quantize',
-          'op_config': {
-              'weight_tensor_config': {
-                  'num_bits': 8,
-                  'symmetric': True,
-                  'granularity': 'CHANNELWISE',
-                  'dtype': 'INT',
-                  'block_size': 0,
-              },
-              'compute_precision': 'INTEGER',
-              'explicit_dequantize': False,
-              'skip_checks': False,
-          },
-      })
-  ]
+AlgorithmName = algorithm_manager.AlgorithmName
 
 
-def dynamic_wi4_afp32():
-  """Returns a dynamic quantization recipe with int4 weights and float32 activation."""
-  return [
-      dict({
-          'regex': '.*',
-          'operation': '*',
-          'algorithm_key': 'min_max_uniform_quantize',
-          'op_config': {
-              'weight_tensor_config': {
-                  'num_bits': 4,
-                  'symmetric': True,
-                  'granularity': 'CHANNELWISE',
-                  'dtype': 'INT',
-                  'block_size': 0,
-              },
-              'compute_precision': 'INTEGER',
-              'explicit_dequantize': False,
-              'skip_checks': False,
-          },
-      })
-  ]
+def dynamic_wi8_afp32(
+    algorithm_key: AlgorithmName = AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+):
+  """Returns a dynamic quantization recipe with int8 weights and float32 activation.
+
+  All supported ops will be quantized with int8 weights and float32 activations,
+  which will be dynamically quantized to int8 during inference to enable int8
+  compute. The model quality may suffer due to the on-the-fly quantization. If
+  quality is a concern, consider using weight-only quantization.
+
+  Args:
+    algorithm_key: The algorithm to use for quantization.
+
+  Returns:
+    A dynamic quantization recipe.
+  """
+  rp_manager = recipe_manager.RecipeManager()
+  rp_manager.add_dynamic_config(
+      regex='.*',
+      operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+      num_bits=8,
+      algorithm_key=algorithm_key,
+  )
+  return rp_manager.get_quantization_recipe()
+
+
+def dynamic_wi4_afp32(
+    algorithm_key: AlgorithmName = AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+):
+  """Returns a dynamic quantization recipe with int4 weights and float32 activation.
+
+  All supported ops will be quantized with int4 weights and float32 activations,
+  which will be dynamically quantized to int4 during inference to enable int4
+  compute.
+
+  Args:
+    algorithm_key: The algorithm to use for quantization.
+
+  Returns:
+    A dynamic quantization recipe.
+  """
+  rp_manager = recipe_manager.RecipeManager()
+  rp_manager.add_dynamic_config(
+      regex='.*',
+      operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+      num_bits=4,
+      algorithm_key=algorithm_key,
+  )
+  return rp_manager.get_quantization_recipe()
+
+
+def weight_only_wi8_afp32(
+    algorithm_key: AlgorithmName = AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+):
+  """Returns a weight-only quantization recipe with int8 weights and float32 activation.
+
+  All supported ops will be quantized with int8 weights and float32 activations.
+  The weights will be explicitly dequantized before being fed into the op to
+  enable float compute thus retain model quality. If latency is a concern,
+  consider using dynamic range quantization.
+
+  Args:
+    algorithm_key: The algorithm to use for quantization.
+
+  Returns:
+    A weight-only quantization recipe.
+  """
+  rp_manager = recipe_manager.RecipeManager()
+  rp_manager.add_weight_only_config(
+      regex='.*',
+      operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+      num_bits=8,
+      algorithm_key=algorithm_key,
+  )
+  return rp_manager.get_quantization_recipe()
+
+
+def weight_only_wi4_afp32(
+    algorithm_key: AlgorithmName = AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+):
+  """Returns a weight-only quantization recipe with int4 weights and float32 activation.
+
+  All supported ops will be quantized with int4 weights and float32 activations.
+  The weights will be explicitly dequantized before being fed into the op to
+  enable float compute thus retain model quality.
+
+  Args:
+    algorithm_key: The algorithm to use for quantization.
+
+  Returns:
+    A weight-only quantization recipe.
+  """
+  rp_manager = recipe_manager.RecipeManager()
+  rp_manager.add_weight_only_config(
+      regex='.*',
+      operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+      num_bits=4,
+      algorithm_key=algorithm_key,
+  )
+  return rp_manager.get_quantization_recipe()
+
+
+def static_wi8_ai8(
+    algorithm_key: AlgorithmName = AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+):
+  """Returns a static quantization recipe with int8 weights and int8 activations.
+
+  All supported ops will be quantized with int8 weights and int8 activations.
+  Calibration is needed to use this recipe.
+
+  Args:
+    algorithm_key: The algorithm to use for quantization.
+
+  Returns:
+    A static quantization recipe.
+  """
+  rp_manager = recipe_manager.RecipeManager()
+  rp_manager.add_static_config(
+      regex='.*',
+      operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+      activation_num_bits=8,
+      weight_num_bits=8,
+      algorithm_key=algorithm_key,
+  )
+  return rp_manager.get_quantization_recipe()
+
+
+def static_wi8_ai16(
+    algorithm_key: AlgorithmName = AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+):
+  """Returns a static quantization recipe with int8 weights and int16 activations.
+
+  All supported ops will be quantized with int8 weights and int16 activations.
+  Calibration is needed to use this recipe.
+
+  Args:
+    algorithm_key: The algorithm to use for quantization.
+
+  Returns:
+    A static quantization recipe.
+  """
+  rp_manager = recipe_manager.RecipeManager()
+  rp_manager.add_static_config(
+      regex='.*',
+      operation_name=qtyping.TFLOperationName.ALL_SUPPORTED,
+      activation_num_bits=16,
+      weight_num_bits=8,
+      algorithm_key=algorithm_key,
+  )
+  return rp_manager.get_quantization_recipe()
 
 
 def dynamic_legacy_wi8_afp32():

ai_edge_quantizer/recipe_manager.py

@@ -243,3 +243,146 @@ class RecipeManager:
       ):
         return True
     return False
+
+  def add_dynamic_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      num_bits: int,
+      granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a dynamic quantization configuration to the recipe.
+
+    During dynamic quantization, activations are not processed by AEQ and
+    remain in float format. The runtime kernel is expected to quantize these
+    activations on-the-fly, as indicated by compute_precision=Integer and
+    explicit_dequantize=False.
+
+    The model quality may suffer due to the on-the-fly quantization. If quality
+    is a concern, consider using weight-only
+    quantization.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      num_bits: Number of bits for quantization.
+      granularity: Granularity of quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    weight_config = qtyping.TensorQuantizationConfig(
+        num_bits=num_bits,
+        symmetric=True,  # LiteRT kernels only support symmetric quantized weights.
+        granularity=granularity,
+    )
+    self.add_quantization_config(
+        regex,
+        operation_name,
+        op_config=_OpQuantizationConfig(
+            weight_tensor_config=weight_config,
+            compute_precision=qtyping.ComputePrecision.INTEGER,
+            explicit_dequantize=False,
+        ),
+        algorithm_key=algorithm_key,
+    )
+
+  def add_weight_only_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      num_bits: int,
+      granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a weight only quantization configuration to the recipe.
+
+    In weight-only quantization, weights are quantized, but the actual operation
+    (op) computation remains in float. The quantized weight is explicitly
+    dequantized before being fed into the op. This is achieved by inserting a
+    dequantize op between the quantized weight and the consuming op. To enable
+    this, both compute_precision will be set to Float and explicit_dequantize to
+    True.
+
+    Weight-only quantization is useful for reducing model size but may
+    not decrease latency due to float computation. However, quantized model
+    generally has better quality than other quantization options (e.g., dynamic
+    range quantization) due to no loss of precision on activations. If latency
+    is a concern, consider using dynamic quantization.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      num_bits: Number of bits for quantization.
+      granularity: Granularity of quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    weight_config = qtyping.TensorQuantizationConfig(
+        num_bits=num_bits,
+        symmetric=True,  # TFL kernels only support symmetric quantized weights.
+        granularity=granularity,
+    )
+    self.add_quantization_config(
+        regex,
+        operation_name,
+        op_config=_OpQuantizationConfig(
+            weight_tensor_config=weight_config,
+            compute_precision=qtyping.ComputePrecision.FLOAT,
+            explicit_dequantize=True,
+        ),
+        algorithm_key=algorithm_key,
+    )
+
+  def add_static_config(
+      self,
+      regex: str,
+      operation_name: _TFLOpName,
+      activation_num_bits: int,
+      weight_num_bits: int,
+      weight_granularity: qtyping.QuantGranularity = qtyping.QuantGranularity.CHANNELWISE,
+      algorithm_key: str = algorithm_manager.AlgorithmName.MIN_MAX_UNIFORM_QUANT,
+  ):
+    """Adds a static range quantization configuration to the recipe.
+
+    In static quantization, both weights and activations are quantized. This
+    requires a calibration step to determine the quantization parameters (e.g.,
+    min/max ranges) for activations. The quantized model uses integer arithmetic
+    for computations, which can lead to significant latency reductions.
+
+    However, calibration is needed to determine the quantization parameters for
+    activations, which requires sample data and may lead to quality loss. If
+    there is no hardware requirement for full integer quantization, consider
+    using dynamic quantization for simplicity.
+
+    Args:
+      regex: Regular expression for layer name matching.
+      operation_name: Target TFLite operation.
+      activation_num_bits: Number of bits for activation quantization.
+      weight_num_bits: Number of bits for weight quantization.
+      weight_granularity: Granularity of weight quantization.
+      algorithm_key: Algorithm key to be applied.
+    """
+    if activation_num_bits not in [16, 8]:
+      raise ValueError(
+          'Activation quantization is only supported for 16 or 8 bits.'
+      )
+    # INT16 is symmetric and INT8 is asymmetric due to LiteRT kernel limitations.
+    activation_symmetric = activation_num_bits == 16
+    activation_config = qtyping.TensorQuantizationConfig(
+        num_bits=activation_num_bits, symmetric=activation_symmetric
+    )
+    weight_config = qtyping.TensorQuantizationConfig(
+        num_bits=weight_num_bits,
+        symmetric=True,  # TFL kernels only support symmetric quantized weights.
+        granularity=weight_granularity,
+    )
+    self.add_quantization_config(
+        regex,
+        operation_name,
+        op_config=_OpQuantizationConfig(
+            activation_tensor_config=activation_config,
+            weight_tensor_config=weight_config,
+            compute_precision=qtyping.ComputePrecision.INTEGER,
+            explicit_dequantize=False,
+        ),
+        algorithm_key=algorithm_key,
+    )

ai_edge_quantizer/recipe_manager_test.py

@@ -293,6 +293,50 @@ class ConfiguratorTest(parameterized.TestCase, googletest.TestCase):
     # DRQ check.
     self.assertEqual(op_config.compute_precision, _ComputePrecision.INTEGER)
 
+  def test_add_dynamic_config(self):
+    self._recipe_manager.add_dynamic_config(
+        regex='.*/Dense/.*',
+        operation_name=_TFLOpName.FULLY_CONNECTED,
+        num_bits=8,
+    )
+    alg_key, op_config = self._recipe_manager.get_quantization_configs(
+        _TFLOpName.FULLY_CONNECTED, 'model/Dense/op'
+    )
+    self.assertEqual(alg_key, _AlgorithmName.MIN_MAX_UNIFORM_QUANT)
+    self.assertEqual(op_config.compute_precision, _ComputePrecision.INTEGER)
+    self.assertFalse(op_config.explicit_dequantize)
+    self.assertIsNone(op_config.activation_tensor_config)
+    weight_tensor_config = op_config.weight_tensor_config
+    self.assertIsNotNone(weight_tensor_config)
+    self.assertEqual(weight_tensor_config.num_bits, 8)
+    self.assertTrue(weight_tensor_config.symmetric)
+    self.assertEqual(
+        weight_tensor_config.granularity,
+        _QuantGranularity.CHANNELWISE,
+    )
+
+  def test_add_weight_only_config(self):
+    self._recipe_manager.add_weight_only_config(
+        regex='.*/Dense/.*',
+        operation_name=_TFLOpName.FULLY_CONNECTED,
+        num_bits=4,
+    )
+    alg_key, op_config = self._recipe_manager.get_quantization_configs(
+        _TFLOpName.FULLY_CONNECTED, 'model/Dense/op'
+    )
+    self.assertEqual(alg_key, _AlgorithmName.MIN_MAX_UNIFORM_QUANT)
+    self.assertEqual(op_config.compute_precision, _ComputePrecision.FLOAT)
+    self.assertTrue(op_config.explicit_dequantize)
+    self.assertIsNone(op_config.activation_tensor_config)
+    weight_tensor_config = op_config.weight_tensor_config
+    self.assertIsNotNone(weight_tensor_config)
+    self.assertEqual(weight_tensor_config.num_bits, 4)
+    self.assertTrue(weight_tensor_config.symmetric)
+    self.assertEqual(
+        weight_tensor_config.granularity,
+        _QuantGranularity.CHANNELWISE,
+    )
+
   def test_set_full_integer_quantization_config(self):
     _add_default_int8xint8_integer_recipe(self._recipe_manager)
     # Full integer setting is global

ai_edge_quantizer/recipe_test.py

@@ -21,6 +21,7 @@ from tensorflow.python.platform import googletest
 from ai_edge_quantizer import quantizer
 from ai_edge_quantizer import recipe
 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('')
@@ -30,21 +31,63 @@ class RecipeTest(parameterized.TestCase):
 
   def setUp(self):
     super().setUp()
-    self._test_model_path = os.path.join(
+    # Weights has < 1024 elements so legacy recipe will not quantize it.
+    self._small_model_path = os.path.join(
         _TEST_DATA_PREFIX_PATH,
         'tests/models/single_conv2d_transpose_bias.tflite',
     )
+    self._test_model_path = os.path.join(
+        _TEST_DATA_PREFIX_PATH,
+        'tests/models/conv_fc_mnist.tflite',
+    )
 
-  def _quantize_with_recipe_func(self, recipe_func):
-    qt = quantizer.Quantizer(self._test_model_path)
+  def _quantize_with_recipe_func(self, recipe_func, test_model_path):
+    qt = quantizer.Quantizer(test_model_path)
     qt.load_quantization_recipe(recipe_func())
     self.assertIsNone(qt._result.quantized_model)
-    quant_result = qt.quantize()
-    self.assertIsNotNone(quant_result.quantized_model)
-    return quant_result
+    if qt.need_calibration:
+      calibration_data = tfl_interpreter_utils.create_random_normal_input_data(
+          qt.float_model,
+          num_samples=1,
+      )
+      calibration_result = qt.calibrate(calibration_data)
+      quantization_result = qt.quantize(calibration_result)
+    else:
+      quantization_result = qt.quantize()
+    self.assertIsNotNone(quantization_result.quantized_model)
+    return quantization_result
 
   def test_quantization_from_dynamic_wi8_afp32_func_succeeds(self):
-    quant_result = self._quantize_with_recipe_func(recipe.dynamic_wi8_afp32)
+    quant_result = self._quantize_with_recipe_func(
+        recipe.dynamic_wi8_afp32, self._test_model_path
+    )
+    self.assertLess(
+        len(quant_result.quantized_model),
+        os.path.getsize(self._test_model_path),
+    )
+
+  def test_quantization_from_dynamic_wi4_afp32_func_succeeds(self):
+    quant_result = self._quantize_with_recipe_func(
+        recipe.dynamic_wi4_afp32, self._test_model_path
+    )
+    self.assertLess(
+        len(quant_result.quantized_model),
+        os.path.getsize(self._test_model_path),
+    )
+
+  def test_quantization_from_weight_only_wi8_afp32_func_succeeds(self):
+    quant_result = self._quantize_with_recipe_func(
+        recipe.weight_only_wi8_afp32, self._test_model_path
+    )
+    self.assertLess(
+        len(quant_result.quantized_model),
+        os.path.getsize(self._test_model_path),
+    )
+
+  def test_quantization_from_weight_only_wi4_afp32_func_succeeds(self):
+    quant_result = self._quantize_with_recipe_func(
+        recipe.weight_only_wi4_afp32, self._test_model_path
+    )
     self.assertLess(
         len(quant_result.quantized_model),
         os.path.getsize(self._test_model_path),
@@ -52,11 +95,12 @@ class RecipeTest(parameterized.TestCase):
 
   def test_quantization_from_dynamic_legacy_wi8_afp32_func_succeeds(self):
     quant_result = self._quantize_with_recipe_func(
-        recipe.dynamic_legacy_wi8_afp32
+        recipe.dynamic_legacy_wi8_afp32,
+        self._small_model_path,
     )
     self.assertLen(
         quant_result.quantized_model,
-        os.path.getsize(self._test_model_path),
+        os.path.getsize(self._small_model_path),
     )
 
   @parameterized.named_parameters(
@@ -65,28 +109,54 @@ class RecipeTest(parameterized.TestCase):
           recipe_json_path='recipes/dynamic_wi8_afp32_recipe.json',
           recipe_func=recipe.dynamic_wi8_afp32,
       ),
+      dict(
+          testcase_name='weight_only_wi8_afp32',
+          recipe_json_path='recipes/default_af32w8float_recipe.json',
+          recipe_func=recipe.weight_only_wi8_afp32,
+      ),
+      dict(
+          testcase_name='weight_only_wi4_afp32',
+          recipe_json_path='recipes/default_af32w4float_recipe.json',
+          recipe_func=recipe.weight_only_wi4_afp32,
+      ),
       dict(
           testcase_name='dynamic_legacy_wi8_afp32',
           recipe_json_path='recipes/dynamic_legacy_wi8_afp32_recipe.json',
           recipe_func=recipe.dynamic_legacy_wi8_afp32,
       ),
+      dict(
+          testcase_name='a8w8',
+          recipe_json_path='recipes/default_a8w8_recipe.json',
+          recipe_func=recipe.static_wi8_ai8,
+      ),
+      dict(
+          testcase_name='a16w8',
+          recipe_json_path='recipes/default_a16w8_recipe.json',
+          recipe_func=recipe.static_wi8_ai16,
+      ),
   )
   def test_recipe_func_and_json_matches(self, recipe_json_path, recipe_func):
     # Quantize with recipe from function in recipe module.
-    quant_result_from_func = self._quantize_with_recipe_func(recipe_func)
+    quant_result_from_func = self._quantize_with_recipe_func(
+        recipe_func, self._test_model_path
+    )
 
     # Quantize with recipe from json file.
     qt_json = quantizer.Quantizer(self._test_model_path)
     json_recipe_path = os.path.join(_TEST_DATA_PREFIX_PATH, recipe_json_path)
     qt_json.load_quantization_recipe(json_recipe_path)
-    quant_result_from_json = qt_json.quantize()
+    if qt_json.need_calibration:
+      calibration_data = tfl_interpreter_utils.create_random_normal_input_data(
+          qt_json.float_model,
+          num_samples=1,
+      )
+      calibration_result = qt_json.calibrate(calibration_data)
+      quant_result_from_json = qt_json.quantize(calibration_result)
+    else:
+      quant_result_from_json = qt_json.quantize()
     self.assertIsNotNone(quant_result_from_json.quantized_model)
 
-    # Check if the recipes and quantized models match.
-    self.assertEqual(
-        quant_result_from_func.recipe,
-        quant_result_from_json.recipe,
-    )
+    # Check if the quantized models match.
     self.assertEqual(
         len(quant_result_from_func.quantized_model),
         len(quant_result_from_json.quantized_model),

ai_edge_quantizer/utils/tfl_flatbuffer_utils.py

@@ -51,6 +51,7 @@ TFL_OP_NAME_TO_CODE = immutabledict.immutabledict({
     _TFLOpName.LOGISTIC: schema.BuiltinOperator.LOGISTIC,
     _TFLOpName.SLICE: schema.BuiltinOperator.SLICE,
     _TFLOpName.SUM: schema.BuiltinOperator.SUM,
+    _TFLOpName.SELECT: schema.BuiltinOperator.SELECT,
     _TFLOpName.SELECT_V2: schema.BuiltinOperator.SELECT_V2,
     _TFLOpName.STABLEHLO_COMPOSITE: schema.BuiltinOperator.STABLEHLO_COMPOSITE,
     _TFLOpName.DYNAMIC_UPDATE_SLICE: (

{ai_edge_quantizer_nightly-0.3.0.dev20250814.dist-info → ai_edge_quantizer_nightly-0.3.0.dev20250816.dist-info}/METADATA

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

@@ -1,24 +1,24 @@
 ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
-ai_edge_quantizer/algorithm_manager.py,sha256=wiX9MTXUEMyUnhQv06EVFtLgFgM6gWCezGUXKotnPPU,13306
+ai_edge_quantizer/algorithm_manager.py,sha256=O_psY-4R0ARmgTQHwfH2px81AJY8PmfamHtE7xJDRjQ,13424
 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=Sms7_AIHPH9G5xFaz5Ef3a5gPhxuIWQI8d2LUM8C96I,12071
-ai_edge_quantizer/calibrator_test.py,sha256=ejKc5YC7id8J1Ll9HAYCzMnKzxd0FUENSD06zkSSV0c,11900
+ai_edge_quantizer/calibrator_test.py,sha256=ZLzIMWB2FSFU4TOatDioYuwp_kLh8iSCefZ5_Q9FU7s,11900
 ai_edge_quantizer/conftest.py,sha256=SxCz-5LlRD_lQm4hQc4c6IGG7DS8d7IyEWY9gnscPN0,794
-ai_edge_quantizer/default_policy.py,sha256=OyWc3fm5A7L28VjMag50yNbQXWJ7GX17JMpwn_pz1GA,11524
+ai_edge_quantizer/default_policy.py,sha256=LXEdwdr0SiCfWo6ZwbHQ8ykoqA40GV6fGAT1aofry3o,11556
 ai_edge_quantizer/model_modifier.py,sha256=teGa8I6kGvn6TQY6Xv53YFIc_pQEhNvM9Zb4bvhezyw,7110
 ai_edge_quantizer/model_modifier_test.py,sha256=cJd04SLOG-fQZZNZPcisoBLx3cLtWEwGqUBbLb-pif4,4751
 ai_edge_quantizer/model_validator.py,sha256=Hj0_5o-Oa3dSlJ3ryVjRhvsyelHNyek1GrtG9buMczg,13153
 ai_edge_quantizer/model_validator_test.py,sha256=EeqOP_mrZsnZ3rug756s0ryDDqd2KgIDld5Lm_gDuWY,13020
 ai_edge_quantizer/params_generator.py,sha256=hcgMHJlERZERUyIAEi6AHJcLJ8gsKIBAEojzFFz-tqk,20098
 ai_edge_quantizer/params_generator_test.py,sha256=RDYoRZDJfEZRtjlTAU2kZ_4t3JHOqEHxfJX9V4ETAhg,40597
-ai_edge_quantizer/qtyping.py,sha256=62OjOcIPV477bICisjU822L6EtnFoJV0kmWgVSrJxXg,16772
-ai_edge_quantizer/quantizer.py,sha256=WeKwhh8cYZ07DUwvS0S1EdNzEZSfPODlynqIBvJ-Br4,13624
-ai_edge_quantizer/quantizer_test.py,sha256=K_HBA56JkFI3HL8VLWCqGEfC0ISh5ldMKoNyBdGRAJg,20368
-ai_edge_quantizer/recipe.py,sha256=FR0uJceumZrnle2VRSOQZ1uXup4S1cTYKRH-N53mWRo,2919
-ai_edge_quantizer/recipe_manager.py,sha256=qcGUD7e7BISKdsY9WH2rdaRR3acmzSA5qMezGNbzlpo,8931
-ai_edge_quantizer/recipe_manager_test.py,sha256=GVOfGFZPRciUb4EF4GkSi6d96LdjS6PbUkAJ0ayy0k8,32243
-ai_edge_quantizer/recipe_test.py,sha256=Fg_sfxovI2fRjk5qdu18ghOvXdUvhDR1TxbE0GHDczc,3381
+ai_edge_quantizer/qtyping.py,sha256=zXXmLBZUT-cfjnQrqDkytDZaGg3z_yy1wWhKr34_XVg,16792
+ai_edge_quantizer/quantizer.py,sha256=ckAEOnnBxuCKZuvlzdChevCKPuE-IeDPHCNtFTWr250,17857
+ai_edge_quantizer/quantizer_test.py,sha256=m6f4ayyaF3yQb9i4V0aFAbmGw0OKZ2Zam1RoTPh-u24,22917
+ai_edge_quantizer/recipe.py,sha256=MEkfQ2Sg3KAE9LAORHWcbjYNPg06EUbwc1d-VspQA2U,6461
+ai_edge_quantizer/recipe_manager.py,sha256=6dgbE-IZfEetzXH3p3Qm_9eQutNDOpZnMpiaLTbP-ZQ,14744
+ai_edge_quantizer/recipe_manager_test.py,sha256=H-B75vwPN5ND-nUa3pOXizeHTv4mufPiC5cL_OlDIYU,34040
+ai_edge_quantizer/recipe_test.py,sha256=GKuo6N65wKLS2xwSpjd-BWWeVRpF1zc7Yt7phSMYSxA,5905
 ai_edge_quantizer/transformation_instruction_generator.py,sha256=iMGXy7_ufqgQRzu4drAfO31VGdze35peEFh1BMZlVHk,27714
 ai_edge_quantizer/transformation_instruction_generator_test.py,sha256=Zw3EOSnvzjuB4NWeo129eJZxK_EHno9oF9OtEQ-0dnM,48905
 ai_edge_quantizer/transformation_performer.py,sha256=o4J6OUbI0dLoobVYjkOFw5Po3yH0gZJXrfuTIYais4o,13029
@@ -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=7H_QHhFKqVxGjhYp-_MXMAUR_VBk2kpATbta9EdhId0,34749
+ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=rkf7jLPVDKpx2ju1LyyP7bxc6n34cLD2E3w2mxLd6qE,35344
 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=BDdn_uBZakfHyzdMJPKadsOqxqyC-s6W2ZzFH99L4fE,8652
 ai_edge_quantizer/algorithms/uniform_quantize/dequantized_weight_recovery_test.py,sha256=sT5eX5TLZEHTtPfnSkCPDlS0sQxlTFWbCsbvOuj--yY,8889
@@ -38,7 +38,7 @@ ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize.py,sha256=1
 ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize_test.py,sha256=nscKDvNb14ErZdAfG0aXRWyRs6bTvhMqMjKx2vxvUK0,8725
 ai_edge_quantizer/algorithms/uniform_quantize/octav.py,sha256=Umxh4kJyeHddZf-Wd4aXE5MTI1XWFa5KRuM17uYU714,6922
 ai_edge_quantizer/algorithms/uniform_quantize/octav_test.py,sha256=sha1d99Xk87bI87tgz0g5LeDC-EeE4WMfM5rRC98-m4,9140
-ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor.py,sha256=0d5XdNbjR2pVsAc-gWX3ik_pAIL-bZ-zemEz_jS2d0c,16531
+ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor.py,sha256=uCREMXi0U2ckhXXfgGVzwSgjFZc0IbtnFU-OjlG9IO8,17146
 ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor_test.py,sha256=7kHluzpteMv36hFD6LD_qnwwMoE1GKUP4bGmGMFbOdA,12755
 ai_edge_quantizer/algorithms/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
 ai_edge_quantizer/algorithms/utils/common_utils.py,sha256=QrEeCuvA7gY_vK1nbKtqassNDClyAjN1ClZIiw63k5U,35895
@@ -62,14 +62,14 @@ ai_edge_quantizer/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V
 ai_edge_quantizer/utils/calibration_utils.py,sha256=e3dG7Nm94Ix0hkTWTWPUhEG6a8QR_cAM3PSwblfJV5g,15106
 ai_edge_quantizer/utils/calibration_utils_test.py,sha256=4BlksXl7b4yptL8xPR67hmJCnjhN9V10a2PunzfHrUE,9372
 ai_edge_quantizer/utils/test_utils.py,sha256=a4Nk-wbeB09dFjTDZiA0K67d26j5DD0UDH_GIVmVG_4,8685
-ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=5QcNk7VTpVJzHhj6wuU4kN-nO609oFvRWVD-9Jbdky0,11330
+ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=RL6oq6FzZj-xV0Zgh0UBn7-fOQaRXSxZ-PPG_LmtyUY,11384
 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/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.3.0.dev20250814.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.3.0.dev20250814.dist-info/METADATA,sha256=t8-2KqfypcSgLS580360EqY75j4Pw0r9ykk1Q7nyQyo,1528
-ai_edge_quantizer_nightly-0.3.0.dev20250814.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ai_edge_quantizer_nightly-0.3.0.dev20250814.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.3.0.dev20250814.dist-info/RECORD,,
+ai_edge_quantizer_nightly-0.3.0.dev20250816.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.3.0.dev20250816.dist-info/METADATA,sha256=WJS_fEwcsNxU--TBLTULHimxyPiJHLhkDrG5b7MWwrg,1528
+ai_edge_quantizer_nightly-0.3.0.dev20250816.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+ai_edge_quantizer_nightly-0.3.0.dev20250816.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.3.0.dev20250816.dist-info/RECORD,,