ai-edge-quantizer-nightly 0.1.0.dev20250415__py3-none-any.whl → 0.5.0.dev20260103__py3-none-any.whl

ai_edge_quantizer/transformations/emulated_subchannel.py

@@ -1,363 +0,0 @@
-# Copyright 2024 The AI Edge Quantizer Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-
-"""Transformation pattern for emulated subchannel quantization."""
-
-from typing import cast
-import numpy as np
-from ai_edge_quantizer import qtyping
-from ai_edge_quantizer.transformations import quantize_tensor
-from ai_edge_quantizer.transformations import transformation_utils
-from ai_edge_litert import schema_py_generated  # pylint: disable=g-direct-tensorflow-import
-
-
-def emulated_subchannel(
-    transformation_input: transformation_utils.TransformationInput,
-) -> qtyping.TransformationInfo:
-  """Emulated subchannel quantization for fully_connected op.
-
-  The input tensor must also be the weight tensor of the fully_connected op.
-
-  after the transformation, the fully connected op will be replaced by:
-  reshape -> batch_matmul -> mul -> sum -> add (if bias is present) ->
-  activation (if fused activation function exist, only support ReLU for now)
-
-  Args:
-    transformation_input: input structure that contains all information needed
-      for the transformation.
-
-  Returns:
-    The transformation info.
-  """
-  # only apply to a single fully_connected op
-  if len(transformation_input.consumers) > 1:
-    raise ValueError('Emulated Subchannel transformation only support one op')
-  if isinstance(
-      transformation_input.quant_params, qtyping.NonLinearQuantParams
-  ):
-    raise ValueError(
-        'Emulated Subchannel transformation only support uniform quantization'
-    )
-  if (
-      transformation_input.op_codes[
-          transformation_input.subgraph.operators[
-              transformation_input.consumers[0]
-          ].opcodeIndex
-      ].builtinCode
-      != schema_py_generated.BuiltinOperator.FULLY_CONNECTED
-  ):
-    raise ValueError(
-        'Emulated Subchannel transformation only support fully_connected op'
-    )
-  if transformation_input.producer != -1:
-    raise ValueError(
-        'Emulated Subchannel transformation only support constant tensor'
-    )
-
-  # insert all tne necessary op codes into the model
-  reshape_op_code_idx = transformation_utils.add_op_code(
-      schema_py_generated.BuiltinOperator.RESHAPE, transformation_input.op_codes
-  )
-  bmm_op_code_idx = transformation_utils.add_op_code(
-      schema_py_generated.BuiltinOperator.BATCH_MATMUL,
-      transformation_input.op_codes,
-  )
-  mul_op_code_idx = transformation_utils.add_op_code(
-      schema_py_generated.BuiltinOperator.MUL, transformation_input.op_codes
-  )
-  sum_op_code_idx = transformation_utils.add_op_code(
-      schema_py_generated.BuiltinOperator.SUM, transformation_input.op_codes
-  )
-
-  original_fc_op_idx = transformation_input.consumers[0]
-  if cast(
-      schema_py_generated.FullyConnectedOptionsT,
-      transformation_input.subgraph.operators[
-          original_fc_op_idx
-      ].builtinOptions,
-  ).fusedActivationFunction not in (
-      schema_py_generated.ActivationFunctionType.NONE,
-      schema_py_generated.ActivationFunctionType.RELU,
-  ):
-    raise ValueError(
-        'Emulated Subchannel transformation only support'
-        ' fusedActivationFunction NONE and RELU for now'
-    )
-
-  weight_tensor = transformation_input.subgraph.tensors[
-      transformation_input.tensor_id
-  ]
-  weight_tensor.type = quantize_tensor.quant_params_to_tflite_type(
-      transformation_input.quant_params.num_bits
-  )
-
-  # modify the weight tensor with the correct quantization parameters
-  transformation_input.buffers[weight_tensor.buffer].data = np.frombuffer(
-      cast(
-          np.ndarray, transformation_input.quant_params.quantized_data
-      ).tobytes(),
-      dtype=np.uint8,
-  )
-  weight_tensor.shape = cast(
-      np.ndarray, transformation_input.quant_params.quantized_data
-  ).shape
-  weight_tensor.quantization.scale = np.ones(shape=[1], dtype=np.float32)
-  weight_tensor.quantization.zeroPoint = np.zeros(
-      shape=[1], dtype=np.int64
-  ).flatten()
-
-  # assuming zero point is 0, so no need to add a zero point tensor
-  for val in transformation_input.quant_params.zero_point.flatten():
-    if val != 0:
-      raise ValueError(
-          'Emulated Subchannel transformation only support zero point 0 for now'
-      )
-
-  scale_tensor_id = transformation_utils.add_new_constant_tensor(
-      weight_tensor.name + b'_scale',
-      transformation_input.quant_params.scale,
-      schema_py_generated.TensorType.FLOAT32,
-      transformation_input.subgraph,
-      transformation_input.buffers,
-  )
-
-  # for fully connected op, the reduce axis is always 1
-  reduce_axes_data = np.array([1], dtype=np.int32)
-  reduce_axes_tensor_id = transformation_utils.add_new_constant_tensor(
-      weight_tensor.name + b'_reduce_axes',
-      reduce_axes_data,
-      schema_py_generated.TensorType.INT32,
-      transformation_input.subgraph,
-      transformation_input.buffers,
-  )
-
-  # find the input and output tensor of the fully connected op
-  activation_input_id = transformation_input.subgraph.operators[
-      transformation_input.consumers[0]
-  ].inputs[0]
-  activation_output_id = transformation_input.subgraph.operators[
-      transformation_input.consumers[0]
-  ].outputs[0]
-  activation_input = transformation_input.subgraph.tensors[activation_input_id]
-  activation_output = transformation_input.subgraph.tensors[
-      activation_output_id
-  ]
-
-  if len(activation_input.shape) != 3:
-    raise ValueError(
-        'Emulated Subchannel transformation only support 3D input tensor'
-    )
-  bmm_input_shape = [
-      activation_input.shape[0] * activation_input.shape[1],
-      weight_tensor.shape[1],
-      1,
-      weight_tensor.shape[2],
-  ]
-  intermediate_tensor_shape = [
-      activation_input.shape[0] * activation_input.shape[1],
-      weight_tensor.shape[1],
-      1,
-      weight_tensor.shape[3],
-  ]
-  sum_output_shape = [
-      activation_input.shape[0] * activation_input.shape[1],
-      1,
-      1,
-      weight_tensor.shape[3],
-  ]
-
-  # create constant tensors for reshape
-  reshape1_shape_id = transformation_utils.add_new_constant_tensor(
-      activation_output.name + b'_reshape_op1_shape',
-      np.array(bmm_input_shape, dtype=np.int32),
-      schema_py_generated.TensorType.INT32,
-      transformation_input.subgraph,
-      transformation_input.buffers,
-  )
-  reshape2_shape_id = transformation_utils.add_new_constant_tensor(
-      activation_output.name + b'_reshape_op2_shape',
-      np.array(activation_output.shape, dtype=np.int32),
-      schema_py_generated.TensorType.INT32,
-      transformation_input.subgraph,
-      transformation_input.buffers,
-  )
-
-  # create all intermediate tensors
-  bmm_input_id = transformation_utils.add_new_activation_tensor(
-      activation_output.name + b'_bmm_input',
-      bmm_input_shape,
-      schema_py_generated.TensorType.FLOAT32,
-      transformation_input.subgraph,
-  )
-  mul_input_id = transformation_utils.add_new_activation_tensor(
-      activation_output.name + b'_mul_input',
-      intermediate_tensor_shape,
-      schema_py_generated.TensorType.FLOAT32,
-      transformation_input.subgraph,
-  )
-  sum_input_id = transformation_utils.add_new_activation_tensor(
-      activation_output.name + b'_reduce_sum_input',
-      intermediate_tensor_shape,
-      schema_py_generated.TensorType.FLOAT32,
-      transformation_input.subgraph,
-  )
-  reshape_op2_input_id = transformation_utils.add_new_activation_tensor(
-      activation_output.name + b'_reshape_op2_input',
-      sum_output_shape,
-      schema_py_generated.TensorType.FLOAT32,
-      transformation_input.subgraph,
-  )
-
-  # reshape
-  reshape_op1 = schema_py_generated.OperatorT()
-  reshape_op1.opcodeIndex = reshape_op_code_idx
-  reshape_op1_option = schema_py_generated.ReshapeOptionsT()
-  reshape_op1_option.newShape = bmm_input_shape
-  reshape_op1.inputs = [activation_input_id, reshape1_shape_id]
-  reshape_op1.outputs = [bmm_input_id]
-  reshape_op1.builtinOptionsType = (
-      schema_py_generated.BuiltinOptions.ReshapeOptions
-  )  # reshape option index
-  reshape_op1.builtinOptions = reshape_op1_option
-
-  # batch_matmul
-  bmm_op = schema_py_generated.OperatorT()
-  bmm_op.opcodeIndex = bmm_op_code_idx
-  bmm_op.inputs = [bmm_input_id, transformation_input.tensor_id]
-  bmm_op.outputs = [mul_input_id]
-  bmm_op.builtinOptionsType = (
-      schema_py_generated.BuiltinOptions.BatchMatMulOptions
-  )
-  bmm_op.builtinOptions = schema_py_generated.BatchMatMulOptionsT()
-
-  # mul
-  mul_op = schema_py_generated.OperatorT()
-  mul_op.opcodeIndex = mul_op_code_idx
-  mul_option = schema_py_generated.MulOptionsT()
-  mul_option.fusedActivationFunction = (
-      schema_py_generated.ActivationFunctionType.NONE
-  )
-  mul_op.inputs = [mul_input_id, scale_tensor_id]
-  mul_op.outputs = [sum_input_id]
-  mul_op.builtinOptionsType = schema_py_generated.BuiltinOptions.MulOptions
-  mul_op.builtinOptions = mul_option
-
-  # sum
-  sum_op = schema_py_generated.OperatorT()
-  sum_op.opcodeIndex = sum_op_code_idx
-  sum_op.inputs = [sum_input_id, reduce_axes_tensor_id]
-  sum_op.outputs = [reshape_op2_input_id]
-  sum_op.builtinOptionsType = schema_py_generated.BuiltinOptions.ReducerOptions
-  sum_op.builtinOptions = schema_py_generated.ReducerOptionsT()
-  sum_op.builtinOptions.keepDims = True
-
-  # reshape
-  reshape_op2 = schema_py_generated.OperatorT()
-  reshape_op2.opcodeIndex = reshape_op_code_idx
-  reshape_op2_option = schema_py_generated.ReshapeOptionsT()
-  reshape_op2_option.newShape = activation_output.shape
-  reshape_op2.inputs = [reshape_op2_input_id, reshape2_shape_id]
-  reshape_op2.outputs = [activation_output_id]
-  reshape_op2.builtinOptionsType = (
-      schema_py_generated.BuiltinOptions.ReshapeOptions
-  )
-  reshape_op2.builtinOptions = reshape_op2_option
-
-  transformation_input.subgraph.operators.insert(
-      original_fc_op_idx, reshape_op1
-  )
-  transformation_input.subgraph.operators.insert(original_fc_op_idx + 1, bmm_op)
-  transformation_input.subgraph.operators.insert(original_fc_op_idx + 2, mul_op)
-  transformation_input.subgraph.operators.insert(original_fc_op_idx + 3, sum_op)
-  transformation_input.subgraph.operators.insert(
-      original_fc_op_idx + 4, reshape_op2
-  )
-  ops_added = 5
-  last_op = reshape_op2
-
-  # If there is a bias tensor (the third input to the original fc op),
-  # we need an add to process it. The current fc op id need to be recalculated
-  # because we added operators in front of it.
-  current_fc_op_id = original_fc_op_idx + ops_added
-  if (
-      len(transformation_input.subgraph.operators[current_fc_op_id].inputs) > 2
-      and transformation_input.subgraph.operators[current_fc_op_id].inputs[2]
-      != -1
-  ):
-    add_op_code_idx = transformation_utils.add_op_code(
-        schema_py_generated.BuiltinOperator.ADD, transformation_input.op_codes
-    )
-    reshape_op2_output_id = transformation_utils.add_new_activation_tensor(
-        activation_output.name + b'_reshape_op2_output',
-        activation_output.shape,
-        schema_py_generated.TensorType.FLOAT32,
-        transformation_input.subgraph,
-    )
-    last_op.outputs = [reshape_op2_output_id]
-    add_op = schema_py_generated.OperatorT()
-    add_op.opcodeIndex = add_op_code_idx
-    add_option = schema_py_generated.AddOptionsT()
-    add_op.builtinOptionsType = schema_py_generated.BuiltinOptions.AddOptions
-    add_op.builtinOptions = add_option
-    add_op.inputs = [
-        reshape_op2_output_id,
-        transformation_input.subgraph.operators[
-            original_fc_op_idx + ops_added
-        ].inputs[2],
-    ]
-    add_op.outputs = [activation_output_id]
-    transformation_input.subgraph.operators.insert(
-        original_fc_op_idx + ops_added, add_op
-    )
-    ops_added += 1
-    last_op = add_op
-
-  # If the fused activation function is RELU, we need to add a relu op.
-  # The current fc op id need to be recalculated because we added operators
-  # in front of it.
-  fc_fused_activation_function = cast(
-      schema_py_generated.FullyConnectedOptionsT,
-      transformation_input.subgraph.operators[
-          original_fc_op_idx + ops_added
-      ].builtinOptions,
-  ).fusedActivationFunction
-  if (
-      fc_fused_activation_function
-      == schema_py_generated.ActivationFunctionType.RELU
-  ):
-    activation_output.name += b'_relu'
-    relu_input_id = transformation_utils.add_new_activation_tensor(
-        activation_output.name + b'_relu_input',
-        activation_output.shape,
-        schema_py_generated.TensorType.FLOAT32,
-        transformation_input.subgraph,
-    )
-    last_op.outputs = [relu_input_id]
-    relu_op = schema_py_generated.OperatorT()
-    relu_op.opcodeIndex = transformation_utils.add_op_code(
-        schema_py_generated.BuiltinOperator.RELU, transformation_input.op_codes
-    )
-    relu_op.inputs = [relu_input_id]
-    relu_op.outputs = [activation_output_id]
-    transformation_input.subgraph.operators.insert(
-        original_fc_op_idx + ops_added, relu_op
-    )
-    ops_added += 1
-    last_op = relu_op
-
-  del transformation_input.subgraph.operators[original_fc_op_idx + ops_added]
-  return qtyping.TransformationInfo(
-      original_fc_op_idx, ops_added - 1, activation_output_id
-  )

ai_edge_quantizer/transformations/emulated_subchannel_test.py

@@ -1,212 +0,0 @@
-# Copyright 2024 The AI Edge Quantizer Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-
-"""Tests for emulated_subchannel."""
-
-import os
-import numpy as np
-from tensorflow.python.platform import googletest
-from ai_edge_quantizer import qtyping
-from ai_edge_quantizer.transformations import emulated_subchannel
-from ai_edge_quantizer.transformations import transformation_utils
-from ai_edge_quantizer.utils import test_utils
-from ai_edge_quantizer.utils import tfl_flatbuffer_utils
-from ai_edge_litert import schema_py_generated  # pylint: disable=g-direct-tensorflow-import
-
-TEST_DATA_PREFIX_PATH = test_utils.get_path_to_datafile("..")
-
-
-class EmulatedSubchannelTest(googletest.TestCase):
-  """Tests for emulated_subchannel."""
-
-  def setUp(self):
-    super().setUp()
-    self.params = qtyping.UniformQuantParams(
-        num_bits=8,
-        quantized_dimension=None,
-        scale=np.ones([1, 1, 1, 4], dtype=np.float32),
-        zero_point=np.zeros([1, 1, 1, 4], dtype=np.int64),
-        symmetric=True,
-        quantized_data=np.ones([1, 4, 2, 4], dtype=np.int8),
-    )
-
-  def test_emulate_subchannel_without_bias_succeeds(self):
-    """Tests the emulated_subchannel function."""
-    self._model_path = os.path.join(
-        TEST_DATA_PREFIX_PATH, "tests/models/single_fc_no_bias.tflite"
-    )
-    self._model = tfl_flatbuffer_utils.read_model(self._model_path)
-    subgraph = self._model.subgraphs[0]
-    model = self._model
-    ret = emulated_subchannel.emulated_subchannel(
-        transformation_utils.TransformationInput(
-            tensor_id=1,
-            op_codes=model.operatorCodes,
-            buffers=model.buffers,
-            subgraph=subgraph,
-            producer=-1,
-            consumers=[0],
-            quant_params=self.params,
-        )
-    )
-    self.assertEqual(ret.op_id, 0)
-    self.assertEqual(ret.num_ops_added, 4)
-    self.assertEqual(ret.output_tensor_id, 2)
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[0].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.RESHAPE,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[1].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.BATCH_MATMUL,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[2].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.MUL,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[3].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.SUM,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[4].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.RESHAPE,
-    )
-    self.assertEqual(
-        subgraph.tensors[subgraph.operators[2].inputs[1]].name,
-        b"arith.constant_scale",
-    )
-    self.assertListEqual(
-        np.frombuffer(
-            model.buffers[
-                subgraph.tensors[subgraph.operators[2].inputs[1]].buffer
-            ].data,
-            dtype=np.float32,
-        ).tolist(),
-        np.ones([1, 1, 1, 4]).flatten().tolist(),
-    )
-
-  def test_emulate_subchannel_with_bias_succeeds(self):
-    """Tests the emulated_subchannel function."""
-    self._model_path = os.path.join(
-        TEST_DATA_PREFIX_PATH, "tests/models/single_fc_bias.tflite"
-    )
-    self._model = tfl_flatbuffer_utils.read_model(self._model_path)
-    subgraph = self._model.subgraphs[0]
-    model = self._model
-    ret = emulated_subchannel.emulated_subchannel(
-        transformation_utils.TransformationInput(
-            tensor_id=1,
-            op_codes=model.operatorCodes,
-            buffers=model.buffers,
-            subgraph=subgraph,
-            producer=-1,
-            consumers=[0],
-            quant_params=self.params,
-        )
-    )
-    self.assertEqual(ret.op_id, 0)
-    self.assertEqual(ret.num_ops_added, 5)
-    self.assertEqual(ret.output_tensor_id, 3)
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[0].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.RESHAPE,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[1].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.BATCH_MATMUL,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[2].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.MUL,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[3].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.SUM,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[4].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.RESHAPE,
-    )
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[5].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.ADD,
-    )
-    self.assertEqual(
-        subgraph.tensors[subgraph.operators[2].inputs[1]].name,
-        b"arith.constant_scale",
-    )
-    self.assertListEqual(
-        np.frombuffer(
-            model.buffers[
-                subgraph.tensors[subgraph.operators[2].inputs[1]].buffer
-            ].data,
-            dtype=np.float32,
-        ).tolist(),
-        np.ones([1, 1, 1, 4]).flatten().tolist(),
-    )
-
-  def test_emulated_subchannel_with_fused_relu_succeeds(self):
-    """Tests the emulated_subchannel function with fused relu."""
-    self._model_path = os.path.join(
-        TEST_DATA_PREFIX_PATH, "tests/models/single_fc_bias_relu.tflite"
-    )
-    self._model = tfl_flatbuffer_utils.read_model(self._model_path)
-    self._model = tfl_flatbuffer_utils.read_model(self._model_path)
-    subgraph = self._model.subgraphs[0]
-    model = self._model
-    ret = emulated_subchannel.emulated_subchannel(
-        transformation_utils.TransformationInput(
-            tensor_id=1,
-            op_codes=model.operatorCodes,
-            buffers=model.buffers,
-            subgraph=subgraph,
-            producer=-1,
-            consumers=[0],
-            quant_params=self.params,
-        )
-    )
-    self.assertEqual(ret.op_id, 0)
-    self.assertEqual(ret.num_ops_added, 6)
-    self.assertEqual(ret.output_tensor_id, 3)
-    self.assertEqual(
-        model.operatorCodes[subgraph.operators[6].opcodeIndex].builtinCode,
-        schema_py_generated.BuiltinOperator.RELU,
-    )
-
-  def test_emulated_subchannel_raises_when_unsupported_activation(self):
-    """Tests the emulated_subchannel function with unsupported activation."""
-    self._model_path = os.path.join(
-        TEST_DATA_PREFIX_PATH, "tests/models/single_fc_bias_relu6.tflite"
-    )
-    self._model = tfl_flatbuffer_utils.read_model(self._model_path)
-    subgraph = self._model.subgraphs[0]
-    model = self._model
-    with self.assertRaises(ValueError):
-      emulated_subchannel.emulated_subchannel(
-          transformation_utils.TransformationInput(
-              tensor_id=1,
-              op_codes=model.operatorCodes,
-              buffers=model.buffers,
-              subgraph=subgraph,
-              producer=-1,
-              consumers=[0],
-              quant_params=self.params,
-          )
-      )
-
-
-if __name__ == "__main__":
-  googletest.main()

ai_edge_quantizer_nightly-0.1.0.dev20250415.dist-info/RECORD

@@ -1,73 +0,0 @@
-ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
-ai_edge_quantizer/algorithm_manager.py,sha256=0uootLsVD6h9ph9TrnXZMI-ExkX8UvXSV0lbWxBLybU,10492
-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=n7AD9j7UScR-CieoI6DQRMeiG_fhLBfSLRiM4460xaM,11895
-ai_edge_quantizer/calibrator_test.py,sha256=C_oWOaRugPKYX74jF-eRFH-k6nGOdA8I9_uPiocaOuE,11900
-ai_edge_quantizer/conftest.py,sha256=SxCz-5LlRD_lQm4hQc4c6IGG7DS8d7IyEWY9gnscPN0,794
-ai_edge_quantizer/default_policy.py,sha256=81z4cruBK7mGFt8xFRZK5LKya65axuZwo2zpbcYSicc,11099
-ai_edge_quantizer/model_modifier.py,sha256=SPt9X-xBzRvcd4xIS24zLHt3aUS2QwsNDqweFqitCAo,7109
-ai_edge_quantizer/model_modifier_test.py,sha256=cJd04SLOG-fQZZNZPcisoBLx3cLtWEwGqUBbLb-pif4,4751
-ai_edge_quantizer/model_validator.py,sha256=fRNz0jO54cthPTibsCuViUXUuFRHl_fbvEiCukIVy20,13030
-ai_edge_quantizer/model_validator_test.py,sha256=EeqOP_mrZsnZ3rug756s0ryDDqd2KgIDld5Lm_gDuWY,13020
-ai_edge_quantizer/params_generator.py,sha256=NEZeHVVIeynmhRzPjl9o-acvWfauFgCS4i45pWFw3V8,20052
-ai_edge_quantizer/params_generator_test.py,sha256=RDYoRZDJfEZRtjlTAU2kZ_4t3JHOqEHxfJX9V4ETAhg,40597
-ai_edge_quantizer/qtyping.py,sha256=FqelZu7j0fGBRSCv_VVsuf3VmbfVlYJGgsjvdMXGgaw,15284
-ai_edge_quantizer/quantizer.py,sha256=g3DMqFMrMpt9jQttCE0WcdNbMtk0JZnmN5MmCHrNdyM,13202
-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=LulVxsYp6TBGFI2PLCUCd4VsFq8ELpC7kMNkUjsLgbo,32230
-ai_edge_quantizer/recipe_test.py,sha256=Fg_sfxovI2fRjk5qdu18ghOvXdUvhDR1TxbE0GHDczc,3381
-ai_edge_quantizer/transformation_instruction_generator.py,sha256=R7A90Qj6iQQROrznXmXLJd-5yXq0PRHbLOdNY51dEu4,27913
-ai_edge_quantizer/transformation_instruction_generator_test.py,sha256=E0QSDCav6N6izlJ-a1ZJOsb2VEUxuxBmTbt0-EgDdxY,49890
-ai_edge_quantizer/transformation_performer.py,sha256=PIrylVhuWZCpnXEl7qSw2BlxRrY7lqj6aQvagJVCVts,11989
-ai_edge_quantizer/transformation_performer_test.py,sha256=n9xI6QMqvrj9KUul2LuObIsF7YdLSqgMg4X6d4BkFP8,15219
-ai_edge_quantizer/algorithms/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/nonlinear_quantize/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/nonlinear_quantize/float_casting.py,sha256=Bs9CK7wZAw6jNaZ8xEtbwO2vM34VYXNZSMVWvxJo9nw,9297
-ai_edge_quantizer/algorithms/nonlinear_quantize/float_casting_test.py,sha256=s64eDDH9bmRWy6Bl1peHnhGewLnFJjvnhYOdjo1zYOA,22625
-ai_edge_quantizer/algorithms/uniform_quantize/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=SVu1RSX5xOWhuNEi9hHqgIDGe_ywyHBZAczp7KAcl3k,27220
-ai_edge_quantizer/algorithms/uniform_quantize/common_quantize_test.py,sha256=qMmKbWqxrCoVKbLKHn9WuCrGKPfHkEyU0Nmhokh8Qeo,2597
-ai_edge_quantizer/algorithms/uniform_quantize/dequantized_weight_recovery.py,sha256=Fk3s9Qy2A_hjUepFOUmTwIZ_wKYVPbdDX4eoP-eoAQU,8726
-ai_edge_quantizer/algorithms/uniform_quantize/dequantized_weight_recovery_test.py,sha256=sT5eX5TLZEHTtPfnSkCPDlS0sQxlTFWbCsbvOuj--yY,8889
-ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize.py,sha256=Divlsn3NjNGtH0vlvE91wxL-VHb4q1nUE0JTDGiEtYc,8572
-ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize_test.py,sha256=zoF_EHjYqsKkuev8wfuutIITEmp_maa70IpJI_Df3ck,7431
-ai_edge_quantizer/algorithms/uniform_quantize/octav.py,sha256=e5wYtki-vl739gSVAZHAKcs2hA87GvFUjVoSUPlnkyM,6433
-ai_edge_quantizer/algorithms/uniform_quantize/octav_test.py,sha256=IcTOaJ1pxtqsitqxOEP9LROVEP_19VFutHalqNied4I,6940
-ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor.py,sha256=WmZzKQlzfu9gFr9SbUDoPY3rFqTl363om8-0rTLwotw,11629
-ai_edge_quantizer/algorithms/uniform_quantize/uniform_quantize_tensor_test.py,sha256=G2PFpHhF-6OOuAwQ1lei63QEIm7uzIZJ62qpgA02qTM,12288
-ai_edge_quantizer/algorithms/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/algorithms/utils/common_utils.py,sha256=4qSlVNx3-91kJufnnJV1RdVRXBPapylZkrAp2nywoao,34581
-ai_edge_quantizer/algorithms/utils/common_utils_test.py,sha256=zqapGEfYhjQWe9cNGPLmdbwtEUUYQRhlO_kNe0cXX6E,18104
-ai_edge_quantizer/transformations/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/transformations/dequant_insert.py,sha256=sL1LHFVzBDSd9jgrzlHz38LWU0bwmVX7iBkaNcui0ts,3566
-ai_edge_quantizer/transformations/dequant_insert_test.py,sha256=NJ18PnG71_AvUPz3Cr_TmG6URMeBfa7IiDDyddfTkKQ,10830
-ai_edge_quantizer/transformations/duplicate_buffer.py,sha256=sEod0EtmcHX0VDqBCI4BYCX9CSRyDtx2vmjtOentFiY,1743
-ai_edge_quantizer/transformations/duplicate_buffer_test.py,sha256=YYWl3Q5WF60s8T8pLzzA8TCSxz-i7dqc03dJt1LtMw4,3880
-ai_edge_quantizer/transformations/duplicate_tensor.py,sha256=HF1uuKFm5kFF6X0XUpdYlLPoikSRd7pIPK1oxN7TuHY,2455
-ai_edge_quantizer/transformations/duplicate_tensor_test.py,sha256=s-RqSxNBMfVJyCunXz2eb7-KA6UiBmbOmL7phLslENQ,5056
-ai_edge_quantizer/transformations/emulated_subchannel.py,sha256=HVaRxoC8PCAvy3xeMv3OIymukUy_yW1zK0xN8Ann6I4,13602
-ai_edge_quantizer/transformations/emulated_subchannel_test.py,sha256=gZP6u9NdPXl7s19qB_Un8evou9ZZV6I9Gy0E1rdobHM,7722
-ai_edge_quantizer/transformations/quant_insert.py,sha256=jn6HsJaV-sqBiFPY-Aqbd64t8zgcYVkEkZI375x_FWY,3958
-ai_edge_quantizer/transformations/quant_insert_test.py,sha256=X9ptPDvJCFkR5tejKnD1SlHFGPazQTW-wNNMV9MEAuw,10107
-ai_edge_quantizer/transformations/quantize_tensor.py,sha256=kjaNrw9mnrn0t8u0vey9S_uPz3iVUicwy4rluxVqV3E,7617
-ai_edge_quantizer/transformations/quantize_tensor_test.py,sha256=mHLO3_MRt36A8-ZN8ADn5tBBJlqjTWa7ZUN8Mmu5Rcw,9116
-ai_edge_quantizer/transformations/transformation_utils.py,sha256=5w0fG6TP362elTHs-JZokl24fuK4Gv6DGyIpybQYb3g,4885
-ai_edge_quantizer/transformations/transformation_utils_test.py,sha256=xH64SF3UHDh84vYbt-WvmXNjM-Jg-mefES1ACO1tkqw,6269
-ai_edge_quantizer/utils/__init__.py,sha256=lpq1g2ayg3lCPLy79t2VicYcnGKw64FfYIj1V7J-4m8,676
-ai_edge_quantizer/utils/calibration_utils.py,sha256=1Fj9MIO6aLZIRgyd4axvZN4S_O64nB_-Miu1WP664js,2536
-ai_edge_quantizer/utils/calibration_utils_test.py,sha256=Z-AcdTieesWFKyKBb08ZXm4Mgu6cvJ4bg2-MJ7hLD10,2856
-ai_edge_quantizer/utils/test_utils.py,sha256=HwZCIpO9fJRAhuN6t6voXKOYQtcioFtt_tpkAlDsAYk,6205
-ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=NKtw60BJAjIE6Yww8B1vJpxXwp4MSERmpKajXJWm5rI,10568
-ai_edge_quantizer/utils/tfl_flatbuffer_utils_test.py,sha256=K1SbK8q92qYVtiVj0I0GtugsPTkpIpEKv9zakvFV_Sc,8555
-ai_edge_quantizer/utils/tfl_interpreter_utils.py,sha256=x2xA2CFPpe_2trcV8v5xGaBETvVCfwAcJuq6yieGJ0Y,12687
-ai_edge_quantizer/utils/tfl_interpreter_utils_test.py,sha256=Op3JxtOqlrjzmYF18jnnstL1k9xiY9kKJ8S2vklKGkc,11327
-ai_edge_quantizer/utils/validation_utils.py,sha256=oYw33Sg547AqtGw-choPUJmp9SAKkV46J_ddqSsum2Q,3950
-ai_edge_quantizer/utils/validation_utils_test.py,sha256=V_qNDikPD4OPB-siOLQCWNVWTAu87h2IgNYt7teFd-o,2934
-ai_edge_quantizer_nightly-0.1.0.dev20250415.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.1.0.dev20250415.dist-info/METADATA,sha256=g6yJhR0N_K05i8jeqweO346MEfkS4c0rIvmwf8tXh6I,1527
-ai_edge_quantizer_nightly-0.1.0.dev20250415.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ai_edge_quantizer_nightly-0.1.0.dev20250415.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.1.0.dev20250415.dist-info/RECORD,,