ai-edge-quantizer-nightly 0.4.0.dev20250929__py3-none-any.whl → 0.4.0.dev20251001__py3-none-any.whl

ai_edge_quantizer/algorithm_manager.py

@@ -61,7 +61,8 @@ class AlgorithmName(str, enum.Enum):
   FLOAT_CASTING = float_casting.ALGORITHM_KEY
   DEQUANTIZED_WEIGHT_RECOVERY = dequantized_weight_recovery.ALGORITHM_KEY
   OCTAV = octav.ALGORITHM_KEY
-  HADAMARD_ROTATION = hadamard_rotation.ALGORITHM_KEY
+  HADAMARD_ROTATION = hadamard_rotation.CUSTOM_OP_ALGORITHM_KEY
+  DECOMPOSED_HADAMARD_ROTATION = hadamard_rotation.DECOMPOSED_ALGORITHM_KEY
   MSE = mse.ALGORITHM_KEY
 
 
@@ -311,8 +312,12 @@ register_config_check_policy_func(
 
 # Register specialized hadamard rotation materialize functions.
 _HADAMARD_ROTATION_OP_NAME_MATERIALIZE_FUNC_DICT = immutabledict({
-    _TFLOpName.FULLY_CONNECTED: hadamard_rotation.materialize_fully_connected,
-    _TFLOpName.EMBEDDING_LOOKUP: hadamard_rotation.materialize_embedding_lookup,
+    _TFLOpName.FULLY_CONNECTED: (
+        hadamard_rotation.materialize_fully_connected_custom_op
+    ),
+    _TFLOpName.EMBEDDING_LOOKUP: (
+        hadamard_rotation.materialize_embedding_lookup_custom_op
+    ),
 })
 for (
     op_name,
@@ -326,6 +331,36 @@ for (
       materialize_func=materialize_func,
   )
 
+register_op_quant_config_validation_func(
+    AlgorithmName.DECOMPOSED_HADAMARD_ROTATION,
+    common_quantize.check_op_quantization_config,
+)
+
+register_config_check_policy_func(
+    AlgorithmName.DECOMPOSED_HADAMARD_ROTATION,
+    default_policy.DEFAULT_CONFIG_CHECK_POLICY,
+)
+
+_DECOMPOSED_HADAMARD_ROTATION_OP_NAME_MATERIALIZE_FUNC_DICT = immutabledict({
+    _TFLOpName.FULLY_CONNECTED: (
+        hadamard_rotation.materialize_fully_connected_decomposed
+    ),
+    _TFLOpName.EMBEDDING_LOOKUP: (
+        hadamard_rotation.materialize_embedding_lookup_decomposed
+    ),
+})
+for (
+    op_name,
+    materialize_func,
+) in _DECOMPOSED_HADAMARD_ROTATION_OP_NAME_MATERIALIZE_FUNC_DICT.items():
+  register_quantized_op(
+      AlgorithmName.DECOMPOSED_HADAMARD_ROTATION,
+      op_name,
+      naive_min_max_quantize.init_qsvs,
+      calibration_func=naive_min_max_quantize.min_max_calibrate,
+      materialize_func=materialize_func,
+  )
+
 
 # Register the MSE algorithm.
 register_op_quant_config_validation_func(

ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation.py

@@ -23,16 +23,17 @@ from ai_edge_quantizer.algorithms.utils import common_utils
 from ai_edge_quantizer.utils import tfl_flatbuffer_utils
 
 
-ALGORITHM_KEY = "HADAMARD_ROTATION"
+CUSTOM_OP_ALGORITHM_KEY = "HADAMARD_ROTATION"
+DECOMPOSED_ALGORITHM_KEY = "DECOMPOSED_HADAMARD_ROTATION"
 
 
 def _make_hadamard_matrix(size: int) -> np.ndarray:
   """Generates a Hadamard matrix of the given size.
 
   Args:
-    size: The size of the Hadamard matrix. Must be a power of 2. This
-      represents a single dimension. E.g. if size is 4, then the Hadamard matrix
-      is a 4x4 matrix.
+    size: The size of the Hadamard matrix. Must be a power of 2. This represents
+      a single dimension. E.g. if size is 4, then the Hadamard matrix is a 4x4
+      matrix.
 
   Returns:
     The Hadamard matrix.
@@ -157,9 +158,10 @@ def get_tensor_quant_params(
   )
 
 
-def materialize_fully_connected(
+def _materialize_fully_connected(
     op_info: qtyping.OpInfo,
     graph_info: qtyping.GraphInfo,
+    is_decomposed: bool = False,
     tensor_name_to_qsv: Optional[dict[str, Any]] = None,  # pylint: disable=unused-argument
 ) -> list[qtyping.TensorTransformationParams]:
   """Materialize the fully_connected op.
@@ -167,12 +169,20 @@ def materialize_fully_connected(
   Args:
     op_info: Aggregated information about the op (e.g., quantization config).
     graph_info: Graph information needed to perform quantization for the op.
+    is_decomposed: Whether to use decomposed Hadamard rotation ops or a custom
+      op.
     tensor_name_to_qsv: A map of tensor name to quantization parameters.
 
   Returns:
     Quantization configuration for the tensors associated with the op (e.g.,
     weights, bias).
   """
+  if op_info.op_quant_config.weight_tensor_config is None:
+    raise ValueError(
+        "Weight tensor quantization config is not provided for Hadamard"
+        " Rotation quantization."
+    )
+
   op_tensor_params = []
 
   # Materialize weight.
@@ -209,7 +219,9 @@ def materialize_fully_connected(
       op_info.op.inputs[input_tensor_index]
   ]
   transformations = [
-      qtyping.QuantTransformation.INSERT_HADAMARD_ROTATION,
+      qtyping.QuantTransformation.INSERT_DECOMPOSED_HADAMARD_ROTATION
+      if is_decomposed
+      else qtyping.QuantTransformation.INSERT_HADAMARD_ROTATION,
   ]
   op2tensor_params = qtyping.OpToTensorParams(
       subgraph_op_id=op_info.subgraph_op_index,
@@ -258,16 +270,45 @@ def materialize_fully_connected(
   return op_tensor_params
 
 
-def materialize_embedding_lookup(
+def materialize_fully_connected_custom_op(
+    op_info: qtyping.OpInfo,
+    graph_info: qtyping.GraphInfo,
+    tensor_name_to_qsv: Optional[dict[str, Any]] = None,  # pylint: disable=unused-argument
+) -> list[qtyping.TensorTransformationParams]:
+  return _materialize_fully_connected(
+      op_info,
+      graph_info,
+      is_decomposed=False,
+      tensor_name_to_qsv=tensor_name_to_qsv,
+  )
+
+
+def materialize_fully_connected_decomposed(
     op_info: qtyping.OpInfo,
     graph_info: qtyping.GraphInfo,
     tensor_name_to_qsv: Optional[dict[str, Any]] = None,  # pylint: disable=unused-argument
+) -> list[qtyping.TensorTransformationParams]:
+  return _materialize_fully_connected(
+      op_info,
+      graph_info,
+      is_decomposed=True,
+      tensor_name_to_qsv=tensor_name_to_qsv,
+  )
+
+
+def _materialize_embedding_lookup(
+    op_info: qtyping.OpInfo,
+    graph_info: qtyping.GraphInfo,
+    is_decomposed: bool = False,
+    tensor_name_to_qsv: Optional[dict[str, Any]] = None,  # pylint: disable=unused-argument
 ) -> list[qtyping.TensorTransformationParams]:
   """Materialize the embedding_lookup op.
 
   Args:
     op_info: Aggregated information about the op (e.g., quantization config).
     graph_info: Graph information needed to perform quantization for the op.
+    is_decomposed: Whether to use decomposed Hadamard rotation ops or a custom
+      op.
     tensor_name_to_qsv: A map of tensor name to quantization parameters.
 
   Returns:
@@ -329,7 +370,9 @@ def materialize_embedding_lookup(
       op_info.op.outputs[output_tensor_index]
   ]
   transformations = [
-      qtyping.QuantTransformation.INSERT_HADAMARD_ROTATION,
+      qtyping.QuantTransformation.INSERT_DECOMPOSED_HADAMARD_ROTATION
+      if is_decomposed
+      else qtyping.QuantTransformation.INSERT_HADAMARD_ROTATION,
   ]
   op2tensor_params = qtyping.OpToTensorParams(
       subgraph_op_id=op_info.subgraph_op_index,
@@ -343,3 +386,29 @@ def materialize_embedding_lookup(
   op_tensor_params.append(output_transformation_params)
 
   return op_tensor_params
+
+
+def materialize_embedding_lookup_custom_op(
+    op_info: qtyping.OpInfo,
+    graph_info: qtyping.GraphInfo,
+    tensor_name_to_qsv: Optional[dict[str, Any]] = None,  # pylint: disable=unused-argument
+) -> list[qtyping.TensorTransformationParams]:
+  return _materialize_embedding_lookup(
+      op_info,
+      graph_info,
+      is_decomposed=False,
+      tensor_name_to_qsv=tensor_name_to_qsv,
+  )
+
+
+def materialize_embedding_lookup_decomposed(
+    op_info: qtyping.OpInfo,
+    graph_info: qtyping.GraphInfo,
+    tensor_name_to_qsv: Optional[dict[str, Any]] = None,  # pylint: disable=unused-argument
+) -> list[qtyping.TensorTransformationParams]:
+  return _materialize_embedding_lookup(
+      op_info,
+      graph_info,
+      is_decomposed=True,
+      tensor_name_to_qsv=tensor_name_to_qsv,
+  )

ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation_test.py

@@ -63,7 +63,7 @@ class HadamardRotationFullyConnectedTest(parameterized.TestCase):
     )
 
   def test_materialize_fully_connected_basic(self):
-    params = hadamard_rotation.materialize_fully_connected(
+    params = hadamard_rotation.materialize_fully_connected_custom_op(
         self._op_info, self._graph_info, self._tensor_name_to_qsv
     )
     fc_input = params[0]
@@ -111,7 +111,7 @@ class HadamardRotationFullyConnectedTest(parameterized.TestCase):
             ),
         ),
     )
-    params = hadamard_rotation.materialize_fully_connected(
+    params = hadamard_rotation.materialize_fully_connected_custom_op(
         self._op_info, self._graph_info, self._tensor_name_to_qsv
     )
     self.assertLen(params, 4)
@@ -152,7 +152,7 @@ class HadamardRotationFullyConnectedTest(parameterized.TestCase):
             ),
         ),
     )
-    params = hadamard_rotation.materialize_fully_connected(
+    params = hadamard_rotation.materialize_fully_connected_custom_op(
         self._op_info, self._graph_info, self._tensor_name_to_qsv
     )
     self.assertLen(params, 4)
@@ -179,6 +179,34 @@ class HadamardRotationFullyConnectedTest(parameterized.TestCase):
     ):
       self.assertEqual(weight.consumers[0].parameters.quantized_dimension, 1)
 
+  def test_materialize_fully_connected_decomposed(self):
+    params = hadamard_rotation.materialize_fully_connected_decomposed(
+        self._op_info, self._graph_info, self._tensor_name_to_qsv
+    )
+    fc_input = params[0]
+    weight = params[1]
+    bias = params[2]
+    output = params[3]
+
+    self.assertLen(params, 4)
+    self.assertEqual(
+        fc_input.consumers[0].transformations,
+        [qtyping.QuantTransformation.INSERT_DECOMPOSED_HADAMARD_ROTATION],
+    )
+    self.assertEqual(
+        weight.consumers[0].transformations,
+        [qtyping.QuantTransformation.QUANTIZE_TENSOR],
+    )
+    self.assertEqual(
+        bias.consumers[0].transformations,
+        [qtyping.QuantTransformation.NO_QUANTIZE],
+    )
+    if output.producer is not None:
+      self.assertEqual(
+          output.producer.transformations,
+          [qtyping.QuantTransformation.NO_QUANTIZE],
+      )
+
   def test_get_tensor_quant_params_basic(self):
     input_tensor = self._subgraph.tensors[self._fc_op.inputs[1]]
     buffer = self._graph_info.buffers[self._fc_buffer_id]
@@ -344,7 +372,7 @@ class HadamardRotationEmbeddingLookupTest(parameterized.TestCase):
             ),
         ),
     )
-    params = hadamard_rotation.materialize_embedding_lookup(
+    params = hadamard_rotation.materialize_embedding_lookup_custom_op(
         op_info, self._graph_info, self._tensor_name_to_qsv
     )
     self.assertLen(params, 3)
@@ -371,6 +399,43 @@ class HadamardRotationEmbeddingLookupTest(parameterized.TestCase):
           [qtyping.QuantTransformation.INSERT_HADAMARD_ROTATION],
       )
 
+  def test_materialize_embedding_lookup_decomposed(self):
+    subgraph = self._test_model.subgraphs[0]
+    embedding_subgraph_op_index = 0
+    embedding_op = subgraph.operators[embedding_subgraph_op_index]
+    op_info = qtyping.OpInfo(
+        op=embedding_op,
+        op_name=_TFLOpName.EMBEDDING_LOOKUP,
+        subgraph_op_index=embedding_subgraph_op_index,
+        op_quant_config=qtyping.OpQuantizationConfig(
+            weight_tensor_config=_TensorQuantConfig(
+                num_bits=8,
+                symmetric=True,
+                granularity=qtyping.QuantGranularity.CHANNELWISE,
+            ),
+        ),
+    )
+    params = hadamard_rotation.materialize_embedding_lookup_decomposed(
+        op_info, self._graph_info, self._tensor_name_to_qsv
+    )
+    self.assertLen(params, 3)
+    lookup = params[0]
+    value = params[1]
+    output = params[2]
+    self.assertEqual(
+        lookup.consumers[0].transformations,
+        [qtyping.QuantTransformation.NO_QUANTIZE],
+    )
+    self.assertEqual(
+        value.consumers[0].transformations,
+        [qtyping.QuantTransformation.QUANTIZE_TENSOR],
+    )
+    if output.producer is not None:
+      self.assertEqual(
+          output.producer.transformations,
+          [qtyping.QuantTransformation.INSERT_DECOMPOSED_HADAMARD_ROTATION],
+      )
+
 
 if __name__ == "__main__":
   googletest.main()

ai_edge_quantizer/params_generator.py

@@ -510,6 +510,7 @@ def _compatible_tensor_params(
       _QuantTrans.ADD_QUANTIZE,
       _QuantTrans.NO_QUANTIZE,
       _QuantTrans.INSERT_HADAMARD_ROTATION,
+      _QuantTrans.INSERT_DECOMPOSED_HADAMARD_ROTATION,
   ]
   quantized_source_transformations = [
       _QuantTrans.QUANTIZE_TENSOR,

ai_edge_quantizer/qtyping.py

@@ -133,6 +133,9 @@ class QuantTransformation(enum.Enum):
   DUPLICATE_TENSOR = 6
   # Insert the aeq.hadamard_rotation op.
   INSERT_HADAMARD_ROTATION = 7
+  # Insert decomposed Hadamard rotation ops. This expresses the Hadamard
+  # rotation as matrix multiplication with Hadamard matrices.
+  INSERT_DECOMPOSED_HADAMARD_ROTATION = 8
 
 
 @dataclasses.dataclass(frozen=True)
@@ -305,6 +308,7 @@ class TensorQuantizationConfig:
       quantization.
     dtype: The data type of the tensor.
     block_size: The block size for blockwise quantization, ignored otherwise.
+    algorithm_key: The algorithm key to use for quantization.
   """
 
   num_bits: int

ai_edge_quantizer/transformation_performer.py

@@ -24,6 +24,7 @@ from ai_edge_quantizer import qtyping
 from ai_edge_quantizer.transformations import dequant_insert
 from ai_edge_quantizer.transformations import duplicate_buffer
 from ai_edge_quantizer.transformations import duplicate_tensor
+from ai_edge_quantizer.transformations import insert_decomposed_hadamard_rotation
 from ai_edge_quantizer.transformations import insert_hadamard_rotation
 from ai_edge_quantizer.transformations import quant_insert
 from ai_edge_quantizer.transformations import quantize_tensor
@@ -83,6 +84,9 @@ class TransformationPerformer:
         qtyping.QuantTransformation.INSERT_HADAMARD_ROTATION: (
             insert_hadamard_rotation.insert_hadamard_rotation
         ),
+        qtyping.QuantTransformation.INSERT_DECOMPOSED_HADAMARD_ROTATION: (
+            insert_decomposed_hadamard_rotation.insert_decomposed_hadamard_rotation
+        ),
     }
     # transformations are seprated in two categories:
     # op_insertion_transformations are transformations that only insert ops
@@ -95,6 +99,7 @@ class TransformationPerformer:
         qtyping.QuantTransformation.DUPLICATE_BUFFER,
         qtyping.QuantTransformation.DUPLICATE_TENSOR,
         qtyping.QuantTransformation.INSERT_HADAMARD_ROTATION,
+        qtyping.QuantTransformation.INSERT_DECOMPOSED_HADAMARD_ROTATION,
     ])
     self._op_replacement_transformations = set(
         [qtyping.QuantTransformation.EMULATED_SUBCHANNEL]

ai_edge_quantizer/transformations/insert_decomposed_hadamard_rotation.py

@@ -0,0 +1,291 @@
+# 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.
+# ==============================================================================
+
+"""Hadamard rotation decomposed pattern transformation."""
+
+from flatbuffers import flexbuffers
+import numpy as np
+from ai_edge_quantizer import qtyping
+from ai_edge_quantizer.transformations import transformation_utils
+from ai_edge_litert import schema_py_generated  # pylint: disable=g-direct-tensorflow-import
+
+
+def _to_flexbuffer(
+    hadamard_size: int,
+    random_binary_vector: list[np.int8],
+) -> bytes:
+  """Converts hadamard_size to flexbuffer."""
+  fbb = flexbuffers.Builder()
+  with fbb.Map():
+    fbb.Int('hadamard_size', hadamard_size)
+    fbb.VectorFromElements('random_binary_vector', random_binary_vector)
+  return fbb.Finish()
+
+
+def _update_embedding_lookup_consumers(
+    transformation: transformation_utils.TransformationInput,
+    new_tensor_id: int,
+) -> bool:
+  """Updates the consumers of the embedding lookup op to use the new tensor.
+
+  Args:
+    transformation: The transformation input to update the consumers of.
+    new_tensor_id: The new tensor id to use as the input to the embedding lookup
+      consumers.
+  """
+  for consumer in transformation.consumers:
+    # If the consumer is a graph output and not an op, we can ignore it here
+    # since the graph output will be updated later.
+    if consumer == -1:
+      continue
+    consumer_op = transformation.subgraph.operators[consumer]
+    # Find the input that was attached to the insertion point, and replace it
+    # with the new tensor.
+    for i in range(len(consumer_op.inputs)):
+      if consumer_op.inputs[i] == transformation.tensor_id:
+        consumer_op.inputs[i] = new_tensor_id
+
+
+def _update_fully_connected_consumers(
+    transformation: transformation_utils.TransformationInput,
+    new_tensor_id: int,
+) -> bool:
+  """Updates the fully connected op(s) to use the new tensor.
+
+  Since the new tensor is inserted to the fully_connected's input, we need to
+  scan each consumer (in case of multiple fully_connected ops), and update
+  the input tensor to the new tensor.
+
+  Args:
+    transformation: The transformation input to update the consumers of.
+    new_tensor_id: The new tensor id to use as the input to the fully connected
+      consumers.
+
+  Returns:
+    True if the fully connected op(s) were updated to use the new tensor.
+  """
+  updated = False
+  for consumer in transformation.consumers:
+    if (
+        transformation_utils.get_schema_op_id(transformation, consumer)
+        == schema_py_generated.BuiltinOperator.FULLY_CONNECTED
+    ):
+      transformation.subgraph.operators[consumer].inputs[0] = new_tensor_id
+      updated = True
+  return updated
+
+
+def _make_hadamard_matrix(size: int):
+  """Generates a Hadamard matrix of the given size.
+
+  Args:
+    size: The size of the Hadamard matrix. Must be a power of 2. This represents
+      a single dimension. E.g. if size is 4, then the Hadamard matrix is a 4x4
+      matrix.
+
+  Returns:
+    The Hadamard matrix.
+
+  Raises:
+    ValueError: If the size is not a power of 2.
+  """
+  if size <= 0 or (size & (size - 1)) != 0:
+    raise ValueError('Hadamard matrix size must be a power of 2. ')
+  h = h2 = np.array([[1, 1], [1, -1]])
+  current_size = 2
+  while current_size < size:
+    h = np.kron(h, h2)
+    current_size *= 2
+  return h / np.sqrt(size)
+
+
+def insert_decomposed_hadamard_rotation(
+    transformation_input: transformation_utils.TransformationInput,
+) -> qtyping.TransformationInfo:
+  """Inserts a decomposed pattern of Hadamard rotation on this tensor.
+
+  This function works for float32 tensors only. Instead of inserting a single
+  custom op (aeq.hadamard_rotation), this inserts the mathematical equivalent
+  expressed in built-in TFLite ops. The mathematical equivalent is:
+    x' = reshape(x, (-1, hadamard_size))
+    x' = x' @ H(hadamard_size)
+    x' = reshape(x, x.shape)
+  where H(n) is a Hadamard matrix of size n.
+
+  Args:
+    transformation_input: The transformation input to insert the ops on.
+
+  Returns:
+    The transformation info of the inserted ops.
+
+  Raises:
+    ValueError: If the transformation input is not a uniform quantization
+    transformation.
+    ValueError: If the Hadamard quantization params are not set.
+    ValueError: If the tensor is not a float32 tensor.
+    ValueError: If no supported ops were found as the tensor's producer or
+    consumers.
+  """
+  if not isinstance(
+      transformation_input.quant_params, qtyping.UniformQuantParams
+  ):
+    raise ValueError('Hadamard rotation supports uniform quantization only')
+
+  if transformation_input.quant_params.hadamard is None:
+    raise ValueError(
+        'Hadamard rotation quantization params are not set but op insertion is'
+        ' requested.'
+    )
+
+  tensor = transformation_input.subgraph.tensors[transformation_input.tensor_id]
+  if tensor.type != schema_py_generated.TensorType.FLOAT32:
+    raise ValueError(
+        'The Hadamard rotation op supports float32 tensors only. Got'
+        f' {tensor.type} tensor.'
+    )
+
+  # Insert x' = tfl.reshape to reshape x to (-1, hadamard_size)
+  hadamard_size = transformation_input.quant_params.hadamard.hadamard_size
+  tensor_size = np.prod(tensor.shape)
+  num_hadamard_blocks = tensor_size // hadamard_size
+  prerotate_shape = [num_hadamard_blocks, hadamard_size]
+  prerotate_shape_tensor_id = transformation_utils.add_new_constant_tensor(
+      tensor.name + b'_prerotate_shape',
+      np.array(prerotate_shape, dtype=np.int32),
+      schema_py_generated.TensorType.INT32,
+      transformation_input.subgraph,
+      transformation_input.buffers,
+  )
+  prerotate_reshape_output_tensor_id = (
+      transformation_utils.add_new_activation_tensor(
+          tensor.name + b'_prerotate_reshaped',
+          prerotate_shape,
+          schema_py_generated.TensorType.FLOAT32,
+          transformation_input.subgraph,
+      )
+  )
+
+  prerotate_reshape_op_code_idx = transformation_utils.add_op_code(
+      schema_py_generated.BuiltinOperator.RESHAPE,
+      transformation_input.op_codes,
+      'RESHAPE',
+  )
+  prerorate_reshape_op = schema_py_generated.OperatorT()
+  prerorate_reshape_op.opcodeIndex = prerotate_reshape_op_code_idx
+  prerorate_reshape_op.inputs = [
+      transformation_input.tensor_id,
+      prerotate_shape_tensor_id,
+  ]
+  prerorate_reshape_op.outputs = [prerotate_reshape_output_tensor_id]
+
+  # Generate hadamard_matrix(hadamard_size).
+  # We could quantize this to INT4 for better memory efficiency, but for large
+  # models the memory overhead is not significant, and floating point
+  # computation does seem to result in better accuracy.
+  hadamard_matrix = _make_hadamard_matrix(hadamard_size)
+  hadamard_matrix_tensor_id = transformation_utils.add_new_constant_tensor(
+      tensor.name + b'_hadamard_matrix',
+      hadamard_matrix.astype(np.float32),
+      schema_py_generated.TensorType.FLOAT32,
+      transformation_input.subgraph,
+      transformation_input.buffers,
+  )
+
+  # Insert x' = tfl.fully_connected(x', hadamard_matrix)
+  fc_output_tensor_id = transformation_utils.add_new_activation_tensor(
+      tensor.name + b'_rotated',
+      prerotate_shape,
+      schema_py_generated.TensorType.FLOAT32,
+      transformation_input.subgraph,
+  )
+
+  fc_op_code_idx = transformation_utils.add_op_code(
+      schema_py_generated.BuiltinOperator.FULLY_CONNECTED,
+      transformation_input.op_codes,
+      'FULLY_CONNECTED',
+  )
+  fc_op = schema_py_generated.OperatorT()
+  fc_op.opcodeIndex = fc_op_code_idx
+  fc_op.inputs = [prerotate_reshape_output_tensor_id, hadamard_matrix_tensor_id]
+  fc_op.outputs = [fc_output_tensor_id]
+
+  # Insert x' = tfl.reshape(x', x.shape)
+  post_reshape_op_code_idx = transformation_utils.add_op_code(
+      schema_py_generated.BuiltinOperator.RESHAPE,
+      transformation_input.op_codes,
+      'RESHAPE',
+  )
+  post_reshape_op = schema_py_generated.OperatorT()
+  post_reshape_op.opcodeIndex = post_reshape_op_code_idx
+  post_reshape_shape_tensor_id = transformation_utils.add_new_constant_tensor(
+      tensor.name + b'_postrotate_shape',
+      np.array(tensor.shape, dtype=np.int32),
+      schema_py_generated.TensorType.INT32,
+      transformation_input.subgraph,
+      transformation_input.buffers,
+  )
+
+  post_reshape_output_tensor_id = (
+      transformation_utils.add_new_activation_tensor(
+          tensor.name + b'_postrotate_reshaped',
+          tensor.shape,
+          schema_py_generated.TensorType.FLOAT32,
+          transformation_input.subgraph,
+      )
+  )
+  post_reshape_op.inputs = [
+      fc_output_tensor_id,
+      post_reshape_shape_tensor_id,
+  ]
+  post_reshape_op.outputs = [post_reshape_output_tensor_id]
+
+  # Update the users of this tensor to use the new tensor.
+  if (
+      transformation_utils.get_producer_schema_op_id(transformation_input)
+      == schema_py_generated.BuiltinOperator.EMBEDDING_LOOKUP
+  ):
+    _update_embedding_lookup_consumers(
+        transformation_input, post_reshape_output_tensor_id
+    )
+  elif not _update_fully_connected_consumers(
+      transformation_input, post_reshape_output_tensor_id
+  ):
+    raise ValueError(
+        'The Hadamard rotation op supports embedding lookup and fully connected'
+        ' ops only, but no such ops were found.'
+    )
+
+  # If the tensor is a graph output, we need to replace the tensor with the
+  # new tensor.
+  for i, output in enumerate(transformation_input.subgraph.outputs):
+    if output == transformation_input.tensor_id:
+      transformation_input.subgraph.outputs[i] = post_reshape_output_tensor_id
+
+  # Find the actual insertion point. The insertion point should be after the
+  # producer op and before the first consumer op. The max() operation ensures
+  # that we're not using -1 as the insertion point.
+  first_consumer_id = min(transformation_input.consumers)
+  op_id = max(transformation_input.producer + 1, first_consumer_id)
+
+  # Insert the new ops in the correct order.
+  transformation_input.subgraph.operators.insert(op_id, prerorate_reshape_op)
+  transformation_input.subgraph.operators.insert(op_id + 1, fc_op)
+  transformation_input.subgraph.operators.insert(op_id + 2, post_reshape_op)
+
+  return qtyping.TransformationInfo(
+      op_id=op_id,
+      num_ops_added=3,
+      output_tensor_id=post_reshape_output_tensor_id,
+  )

ai_edge_quantizer/transformations/insert_decomposed_hadamard_rotation_test.py

@@ -0,0 +1,244 @@
+# 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.
+# ==============================================================================
+
+"""Test insertion of the Decomposed Hadamard rotation ops."""
+
+import os
+import numpy as np
+from tensorflow.python.platform import googletest
+from ai_edge_quantizer import qtyping
+from ai_edge_quantizer.transformations import insert_decomposed_hadamard_rotation
+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 InsertDecomposedHadamardRotationFullyConnectedTest(googletest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    model_path = os.path.join(
+        _TEST_DATA_PREFIX_PATH, 'tests/models/single_fc_bias.tflite'
+    )
+    self.model = tfl_flatbuffer_utils.read_model(model_path)
+    self.params = qtyping.UniformQuantParams(
+        num_bits=8,
+        quantized_dimension=None,
+        scale=np.ones(1),
+        zero_point=np.zeros(1),
+        hadamard=qtyping.UniformQuantParams.HadamardRotationParams(
+            random_binary_vector=np.ones(1),
+            hadamard_size=2,
+        ),
+    )
+
+  def test_raise_unsupported_qparams(self):
+    with self.assertRaisesWithPredicateMatch(
+        ValueError, lambda err: 'uniform quantization' in str(err)
+    ):
+      insert_decomposed_hadamard_rotation.insert_decomposed_hadamard_rotation(
+          transformation_utils.TransformationInput(
+              tensor_id=0,
+              op_codes=self.model.operatorCodes,
+              buffers=self.model.buffers,
+              subgraph=self.model.subgraphs[0],
+              producer=-1,
+              consumers=[-1],
+              quant_params=qtyping.NonLinearQuantParams(
+                  num_bits=16, quantized_data=None
+              ),
+          )
+      )
+
+  def test_raise_missing_hadamard_data(self):
+    with self.assertRaisesWithPredicateMatch(
+        ValueError, lambda err: 'quantization params are not set' in str(err)
+    ):
+      insert_decomposed_hadamard_rotation.insert_decomposed_hadamard_rotation(
+          transformation_utils.TransformationInput(
+              tensor_id=0,
+              op_codes=self.model.operatorCodes,
+              buffers=self.model.buffers,
+              subgraph=self.model.subgraphs[0],
+              producer=-1,
+              consumers=[-1],
+              quant_params=qtyping.UniformQuantParams(
+                  num_bits=8,
+                  quantized_dimension=None,
+                  scale=np.ones(1),
+                  zero_point=np.zeros(1),
+              ),
+          )
+      )
+
+  def test_raise_non_float32_tensor(self):
+    self.model.subgraphs[0].tensors[
+        0
+    ].type = schema_py_generated.TensorType.INT32
+    with self.assertRaisesWithPredicateMatch(
+        ValueError, lambda err: 'float32 tensors' in str(err)
+    ):
+      insert_decomposed_hadamard_rotation.insert_decomposed_hadamard_rotation(
+          transformation_utils.TransformationInput(
+              tensor_id=0,
+              op_codes=self.model.operatorCodes,
+              buffers=self.model.buffers,
+              subgraph=self.model.subgraphs[0],
+              producer=-1,
+              consumers=[-1],
+              quant_params=self.params,
+          ),
+      )
+
+  def test_insert_decomposed_ops(self):
+    # Insert Decomposed Hadamard ops before fully_connected
+    info = (
+        insert_decomposed_hadamard_rotation.insert_decomposed_hadamard_rotation(
+            transformation_utils.TransformationInput(
+                tensor_id=0,
+                op_codes=self.model.operatorCodes,
+                buffers=self.model.buffers,
+                subgraph=self.model.subgraphs[0],
+                producer=-1,
+                consumers=[0],  # Consumer is the FC op
+                quant_params=self.params,
+            )
+        )
+    )
+    subgraph = self.model.subgraphs[0]
+    self.assertEqual(info.op_id, 0)
+    self.assertEqual(info.num_ops_added, 3)
+    # Model had 4 tensors, added 6 tensors (3 activations 3 constants).
+    self.assertEqual(info.output_tensor_id, 9)
+    self.assertLen(subgraph.tensors, 10)
+    # Model had 1 op code, added RESHAPE and FC.
+    self.assertLen(self.model.operatorCodes, 3)
+    self.assertEqual(
+        self.model.operatorCodes[1].builtinCode,
+        schema_py_generated.BuiltinOperator.RESHAPE,
+    )
+    self.assertEqual(
+        self.model.operatorCodes[2].builtinCode,
+        schema_py_generated.BuiltinOperator.FULLY_CONNECTED,
+    )
+
+    # Op 0: RESHAPE
+    reshape_op = subgraph.operators[0]
+    self.assertEqual(
+        self.model.operatorCodes[reshape_op.opcodeIndex].builtinCode,
+        schema_py_generated.BuiltinOperator.RESHAPE,
+    )
+    self.assertEqual(reshape_op.inputs[0], 0)  # Graph input
+    self.assertEqual(reshape_op.outputs[0], 5)  # Reshape output
+
+    # Op 1: FULLY_CONNECTED
+    fc_op = subgraph.operators[1]
+    self.assertEqual(
+        self.model.operatorCodes[fc_op.opcodeIndex].builtinCode,
+        schema_py_generated.BuiltinOperator.FULLY_CONNECTED,
+    )
+    self.assertEqual(fc_op.inputs[0], 5)  # Reshape output
+    self.assertEqual(fc_op.inputs[1], 6)  # Hadamard matrix tensor
+    self.assertEqual(fc_op.outputs[0], 7)  # FC output
+
+    # Op 2: RESHAPE (post)
+    post_reshape_op = subgraph.operators[2]
+    self.assertEqual(
+        self.model.operatorCodes[post_reshape_op.opcodeIndex].builtinCode,
+        schema_py_generated.BuiltinOperator.RESHAPE,
+    )
+    self.assertEqual(post_reshape_op.inputs[0], 7)  # FC output
+    self.assertEqual(post_reshape_op.outputs[0], 9)  # Post Reshape output
+
+    # Op 3: Original FULLY_CONNECTED
+    orig_fc_op = subgraph.operators[3]
+    self.assertEqual(
+        self.model.operatorCodes[orig_fc_op.opcodeIndex].builtinCode,
+        schema_py_generated.BuiltinOperator.FULLY_CONNECTED,
+    )
+    # Input to the original FC is the post reshape output
+    self.assertEqual(orig_fc_op.inputs[0], 9)
+
+
+class InsertDecomposedHadamardRotationEmbeddingLookupTest(googletest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    model_path = os.path.join(
+        _TEST_DATA_PREFIX_PATH, 'tests/models/embedding_lookup.tflite'
+    )
+    self.model = tfl_flatbuffer_utils.read_model(model_path)
+    self.params = qtyping.UniformQuantParams(
+        num_bits=8,
+        quantized_dimension=None,
+        scale=np.ones(1),
+        zero_point=np.zeros(1),
+        hadamard=qtyping.UniformQuantParams.HadamardRotationParams(
+            random_binary_vector=np.ones(1),
+            hadamard_size=2,
+        ),
+    )
+
+  def test_insert_decomposed_ops(self):
+    # Insert Decomposed Hadamard ops after embedding_lookup
+    info = (
+        insert_decomposed_hadamard_rotation.insert_decomposed_hadamard_rotation(
+            transformation_utils.TransformationInput(
+                tensor_id=2,  # Output of embedding_lookup
+                op_codes=self.model.operatorCodes,
+                buffers=self.model.buffers,
+                subgraph=self.model.subgraphs[0],
+                producer=0,
+                consumers=[-1],  # Output is a graph output
+                quant_params=self.params,
+            )
+        )
+    )
+    subgraph = self.model.subgraphs[0]
+    self.assertEqual(info.op_id, 1)
+    self.assertEqual(info.num_ops_added, 3)
+    # Model had 3 tensors, added 6 (3 activations 3 constants).
+    self.assertEqual(info.output_tensor_id, 8)
+    self.assertLen(subgraph.tensors, 9)
+    # Model had 1 op code, added RESHAPE and FC.
+    self.assertLen(self.model.operatorCodes, 3)
+
+    # Op 0: EMBEDDING_LOOKUP (Original)
+    # Op 1: RESHAPE
+    reshape_op = subgraph.operators[1]
+    self.assertEqual(reshape_op.inputs[0], 2)  # Embedding lookup output
+    self.assertEqual(reshape_op.outputs[0], 4)
+
+    # Op 2: FULLY_CONNECTED
+    fc_op = subgraph.operators[2]
+    self.assertEqual(fc_op.inputs[0], 4)
+    self.assertEqual(fc_op.inputs[1], 5)  # Hadamard matrix
+    self.assertEqual(fc_op.outputs[0], 6)
+
+    # Op 3: RESHAPE (post)
+    post_reshape_op = subgraph.operators[3]
+    self.assertEqual(post_reshape_op.inputs[0], 6)
+    self.assertEqual(post_reshape_op.outputs[0], 8)
+
+    # Check graph output
+    self.assertIn(8, subgraph.outputs)
+    self.assertNotIn(2, subgraph.outputs)
+
+
+if __name__ == '__main__':
+  googletest.main()

ai_edge_quantizer/transformations/insert_hadamard_rotation.py

@@ -34,35 +34,6 @@ def _to_flexbuffer(
   return fbb.Finish()
 
 
-def _is_producer_embedding_lookup(
-    transformation: transformation_utils.TransformationInput,
-) -> bool:
-  """Checks if the tensor's producer is an embedding lookup op."""
-  if transformation.producer == -1:
-    return False
-  else:
-    return (
-        transformation.op_codes[
-            transformation.subgraph.operators[
-                transformation.producer
-            ].opcodeIndex
-        ].builtinCode
-        == schema_py_generated.BuiltinOperator.EMBEDDING_LOOKUP
-    )
-
-
-def _is_fully_connected(
-    transformation: transformation_utils.TransformationInput, op_id: int
-) -> bool:
-  """Checks if the any of the tensor's consumers is a fully connected op."""
-  return (
-      transformation.op_codes[
-          transformation.subgraph.operators[op_id].opcodeIndex
-      ].builtinCode
-      == schema_py_generated.BuiltinOperator.FULLY_CONNECTED
-  )
-
-
 def _update_embedding_lookup_consumers(
     transformation: transformation_utils.TransformationInput,
     new_tensor_id: int,
@@ -107,7 +78,10 @@ def _update_fully_connected_consumers(
   """
   updated = False
   for consumer in transformation.consumers:
-    if _is_fully_connected(transformation, consumer):
+    if (
+        transformation_utils.get_schema_op_id(transformation, consumer)
+        == schema_py_generated.BuiltinOperator.FULLY_CONNECTED
+    ):
       transformation.subgraph.operators[consumer].inputs[0] = new_tensor_id
       updated = True
   return updated
@@ -177,7 +151,10 @@ def insert_hadamard_rotation(
   custom_op.outputs = [new_tensor_id]
 
   # Update the users of this tensor to use the new tensor.
-  if _is_producer_embedding_lookup(transformation_input):
+  if (
+      transformation_utils.get_producer_schema_op_id(transformation_input)
+      == schema_py_generated.BuiltinOperator.EMBEDDING_LOOKUP
+  ):
     _update_embedding_lookup_consumers(transformation_input, new_tensor_id)
   elif not _update_fully_connected_consumers(
       transformation_input, new_tensor_id

ai_edge_quantizer/transformations/quantize_tensor.py

@@ -68,29 +68,6 @@ def nonlinear_quant_params_to_tflite_type(
     raise ValueError(f"Unsupported nonlinear params: {bitwidth}")
 
 
-def _pack_data(bitwidth: int, flattened_data: np.ndarray) -> np.ndarray:
-  """Pack the data to the corresponding bit width.
-
-  Currently only support 4 bits. If no packing is needed, the original data is
-  returned.
-
-  Args:
-    bitwidth: Bit width from NonLinearQuantParams.
-    flattened_data: The data to be packed.
-
-  Returns:
-    Packed data.
-  """
-  if bitwidth == 4:
-    even_data = flattened_data[::2] & 0x0F
-    odd_data = np.left_shift(flattened_data[1::2], 4).astype(np.uint8)
-    if odd_data.shape[0] == even_data.shape[0] - 1:
-      odd_data = np.pad(odd_data, (0, 1), constant_values=0)
-    return np.bitwise_or(even_data, odd_data)
-  else:
-    return flattened_data
-
-
 def _perform_channelwise_quantization(
     transformation_input: transformation_utils.TransformationInput,
 ) -> schema_py_generated.QuantizationParametersT():
@@ -180,14 +157,17 @@ def quantize_tensor(
   # is not provided.
   if tensor.buffer:
     if transformation_input.quant_params.quantized_data is not None:
-      transformation_input.buffers[tensor.buffer].data = _pack_data(
-          transformation_input.quant_params.num_bits,
-          np.frombuffer(
-              cast(
-                  np.ndarray, transformation_input.quant_params.quantized_data
-              ).tobytes(),
-              dtype=np.uint8,
-          ).flatten(),
+      transformation_input.buffers[tensor.buffer].data = (
+          transformation_utils.pack_data(
+              transformation_input.quant_params.num_bits,
+              np.frombuffer(
+                  cast(
+                      np.ndarray,
+                      transformation_input.quant_params.quantized_data,
+                  ).tobytes(),
+                  dtype=np.uint8,
+              ).flatten(),
+          )
       )
 
   if isinstance(transformation_input.quant_params, qtyping.UniformQuantParams):

ai_edge_quantizer/transformations/transformation_utils.py

@@ -210,3 +210,69 @@ def raise_deprecated_error(_: TransformationInput):
       'This transformation is deprecated. Please contact AI Edge Quantizer team'
       ' if you see this error.'
   )
+
+
+def pack_data(bitwidth: int, flattened_data: np.ndarray) -> np.ndarray:
+  """Pack the data to the corresponding bit width.
+
+  Currently only support 4 bits. If no packing is needed, the original data is
+  returned.
+
+  Args:
+    bitwidth: Bit width from NonLinearQuantParams.
+    flattened_data: The data to be packed.
+
+  Returns:
+    Packed data.
+  """
+  if bitwidth == 4:
+    even_data = flattened_data[::2] & 0x0F
+    odd_data = np.left_shift(flattened_data[1::2], 4).astype(np.uint8)
+    if odd_data.shape[0] == even_data.shape[0] - 1:
+      odd_data = np.pad(odd_data, (0, 1), constant_values=0)
+    return np.bitwise_or(even_data, odd_data)
+  else:
+    return flattened_data
+
+
+def get_producer_schema_op_id(
+    transformation: TransformationInput,
+) -> int:
+  """Checks if the tensor's producer matches the given op.
+
+  Args:
+    transformation: The transformation input to check the producer of.
+
+  Returns:
+    The schema op id of the producer op. E.g.
+    schema_py_generated.BuiltinOperator.FULLY_CONNECTED.
+  """
+  if transformation.producer == -1:
+    return False
+  else:
+    return (
+        transformation.op_codes[
+            transformation.subgraph.operators[
+                transformation.producer
+            ].opcodeIndex
+        ].builtinCode
+    )
+
+
+def get_schema_op_id(
+    transformation: TransformationInput, op_id: int
+) -> bool:
+  """Returns the schema op id of the given op.
+
+  Args:
+    transformation: The transformation input to check the consumers of.
+    op_id: The op id in the list of operators to check for.
+
+  Returns:
+    The schema op id of the given op.
+  """
+  return (
+      transformation.op_codes[
+          transformation.subgraph.operators[op_id].opcodeIndex
+      ].builtinCode
+  )

ai_edge_quantizer/utils/validation_utils.py

@@ -38,6 +38,8 @@ def get_validation_func(
     return mean_squared_difference
   elif func_name == "median_diff_ratio":
     return median_diff_ratio
+  elif func_name == "cosine_similarity":
+    return cosine_similarity
   else:
     raise ValueError(f"Validation function {func_name} not supported")
 
@@ -99,6 +101,33 @@ 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:
+    Value error 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)
+  return float(
+      np.dot(data1, data2) / (np.linalg.norm(data1) * np.linalg.norm(data2))
+  )
+
+
 def _preprocess_same_size_arrays(
     data1: np._typing.ArrayLike, data2: np._typing.ArrayLike
 ) -> Tuple[np.ndarray, np.ndarray]:

ai_edge_quantizer/utils/validation_utils_test.py

@@ -82,6 +82,30 @@ 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)
+
 
 if __name__ == "__main__":
   googletest.main()

{ai_edge_quantizer_nightly-0.4.0.dev20250929.dist-info → ai_edge_quantizer_nightly-0.4.0.dev20251001.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
 ai_edge_quantizer/__init__.py,sha256=4pFSkukSwahYyzwqia0yPRyz8TnFQfGRthVJhYpMWas,793
-ai_edge_quantizer/algorithm_manager.py,sha256=XkLMG_wQqf_X6swp6YBIhJpIbIdRcOt2LJ_6oTZ3GzU,14956
+ai_edge_quantizer/algorithm_manager.py,sha256=6-kM-pV6N7vCY7c043fWXuGTNHWdXqvI3ezDxjBdrx0,16022
 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
@@ -10,9 +10,9 @@ ai_edge_quantizer/model_modifier.py,sha256=teGa8I6kGvn6TQY6Xv53YFIc_pQEhNvM9Zb4b
 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.py,sha256=0w-sDGk84sVNkXoduon1wDqq30sGOHVgBVbdg44QVF4,20153
 ai_edge_quantizer/params_generator_test.py,sha256=RDYoRZDJfEZRtjlTAU2kZ_4t3JHOqEHxfJX9V4ETAhg,40597
-ai_edge_quantizer/qtyping.py,sha256=tfrPip-uzJuF_PASgUExx5Oy9gghWUbQaApR0XaBpNw,16882
+ai_edge_quantizer/qtyping.py,sha256=gBNBPuh488IujrpCTIoNrPKRXJXdsuzbzl7oi7MPZpc,17121
 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
@@ -21,7 +21,7 @@ ai_edge_quantizer/recipe_manager_test.py,sha256=qjgGUF-wggXnSXqZ5khmqrDMIQI5CShk
 ai_edge_quantizer/recipe_test.py,sha256=QisyaTol8JRZFcGOGyee7QRCvqj5VbF4guKWdIoMUOE,6213
 ai_edge_quantizer/transformation_instruction_generator.py,sha256=O0U2aZcB8aXQgOV8r9g1rGNzDUiuI5Ta53XnxZbVffE,31576
 ai_edge_quantizer/transformation_instruction_generator_test.py,sha256=KW5-WoTTo9IqLEVnWxVC8ut8eWLi_91xfKgGqVQ9QDk,54635
-ai_edge_quantizer/transformation_performer.py,sha256=o4J6OUbI0dLoobVYjkOFw5Po3yH0gZJXrfuTIYais4o,13029
+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
@@ -32,8 +32,8 @@ ai_edge_quantizer/algorithms/uniform_quantize/common_quantize.py,sha256=E17cSR-M
 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
-ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation.py,sha256=otKRiZn_C0QH0891pxLsIPIBT1mLDwbKYYP7bI-MXAA,12279
-ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation_test.py,sha256=_SpP12aDLujv_7tWf_mCt89WknNXTSGE-JpZWO1bYSE,13238
+ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation.py,sha256=qxt9CPDcidVWIxp5nSWPN2hKKj1XZcsOOLBd2SYIvW0,14572
+ai_edge_quantizer/algorithms/uniform_quantize/hadamard_rotation_test.py,sha256=mgv6aGIqQouxfA8_GacuGdOftvL75XBF1_h5tlCCYJQ,15468
 ai_edge_quantizer/algorithms/uniform_quantize/mse.py,sha256=qiIyzogATGVxjYwxzH0cZvgwPSPBJv_3y8NSumHZXTk,4561
 ai_edge_quantizer/algorithms/uniform_quantize/mse_test.py,sha256=-_P4jQJ7gVo0FNSapP3sIGcnhwfjQHW1AKLfoiAlS_s,7142
 ai_edge_quantizer/algorithms/uniform_quantize/naive_min_max_quantize.py,sha256=1sB2j1vlvvWDKyjcGvA_JLCpN2KbCmMslGCBUc4--V4,8461
@@ -52,13 +52,15 @@ ai_edge_quantizer/transformations/duplicate_buffer.py,sha256=TvTHbm24IiICNkWOlvR
 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_hadamard_rotation.py,sha256=rBbKgcVKHie38NT2UQ7KQ1xCb2tRu_rVl0yFloOAW_A,7562
+ai_edge_quantizer/transformations/insert_decomposed_hadamard_rotation.py,sha256=D47xTbMQM-R2X3SwSG1RjOAKxvGp76y61aaZA1VyN8E,10791
+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=kjaNrw9mnrn0t8u0vey9S_uPz3iVUicwy4rluxVqV3E,7617
+ai_edge_quantizer/transformations/quantize_tensor.py,sha256=unqInO0we6_cgwPjtHB3tLWIHPajfNuJSLGW-IFnI9E,7029
 ai_edge_quantizer/transformations/quantize_tensor_test.py,sha256=mHLO3_MRt36A8-ZN8ADn5tBBJlqjTWa7ZUN8Mmu5Rcw,9116
-ai_edge_quantizer/transformations/transformation_utils.py,sha256=efJdAkA24wlg6Vj5NFO7_7MDuvQLSNn-l11Vs_JPktI,7123
+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=iMf_bSCf-O86MzDt5D9hLKqbTydqLwirluaC6BJ9yHo,11553
@@ -70,10 +72,10 @@ ai_edge_quantizer/utils/tfl_flatbuffer_utils.py,sha256=anbxbIKS7t8iIkJZJH7AkAR18
 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.4.0.dev20250929.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ai_edge_quantizer_nightly-0.4.0.dev20250929.dist-info/METADATA,sha256=GahuH88Vm8RgFgALE2Fhk4UqufuY8bLxH4G_sfZ3c3I,1508
-ai_edge_quantizer_nightly-0.4.0.dev20250929.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ai_edge_quantizer_nightly-0.4.0.dev20250929.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
-ai_edge_quantizer_nightly-0.4.0.dev20250929.dist-info/RECORD,,
+ai_edge_quantizer/utils/validation_utils.py,sha256=yJH9Cvepr_XWn-3Hsh91j7HuC5iLQHAyskyQ48bGNoc,4797
+ai_edge_quantizer/utils/validation_utils_test.py,sha256=1sblJWHLTYTbn1Qi9rwnrREOSXRy5KwHAWSwgI1e_aU,3697
+ai_edge_quantizer_nightly-0.4.0.dev20251001.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ai_edge_quantizer_nightly-0.4.0.dev20251001.dist-info/METADATA,sha256=Lz_ZDdMl2fFALbGbeUJwv3sP8ZrgOsYLLgdlD5p5G-I,1508
+ai_edge_quantizer_nightly-0.4.0.dev20251001.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+ai_edge_quantizer_nightly-0.4.0.dev20251001.dist-info/top_level.txt,sha256=8QTfPnFXNVUhScFLaa-NWZMFWMn72M50DVPubpwWB1g,18
+ai_edge_quantizer_nightly-0.4.0.dev20251001.dist-info/RECORD,,