hgq2 rename

Author: calad0i

.pre-commit-config.yaml

@@ -48,7 +48,7 @@ repos:
     additional_dependencies: [flake8-bugbear, flake8-print]
     args: ['--max-line-length=125',  # github viewer width
            '--extend-ignore=E203,T201',  # E203 is not PEP8 compliant
-           '--per-file-ignores=hls4ml/model/optimizer/passes/bit_exact.py:E741,hls4ml/converters/keras_v3/squark/_base.py:E741,__init__.py:F401',
+           '--per-file-ignores=hls4ml/model/optimizer/passes/bit_exact.py:E741,__init__.py:F401',
            # i for #int w/o sign, I for #int w/ sign when massively processing bw conversions ......
            # ignore unused imports in __init__.py .....
     ]

hls4ml/converters/keras_v3/__init__.py

@@ -1,7 +1,7 @@
 from . import conv  # noqa: F401
 from . import core  # noqa: F401
 from . import einsum_dense  # noqa: F401
-from . import squark  # noqa: F401
+from . import hgq2  # noqa: F401
 from ._base import registry as layer_handlers
 
 __all__ = ['layer_handlers']

hls4ml/converters/keras_v3/squark/__init__.py renamed to hls4ml/converters/keras_v3/hgq2/__init__.py

@@ -9,26 +9,26 @@
 from hls4ml.converters.keras_v3.einsum_dense import KV3EinsumDenseHandler
 
 if TYPE_CHECKING:
-    import squark
+    import hgq
     from keras.api import KerasTensor, Layer
 
 
 def extract_fixed_quantizer_config(q, tensor: 'KerasTensor', is_input: bool) -> dict[str, Any]:
+    from hgq.quantizer.internal.fixed_point_quantizer import FixedPointQuantizerKBI, FixedPointQuantizerKIF
     from keras.api.ops import convert_to_numpy
-    from squark.quantizer.internal.fixed_point_quantizer import FixedPointQuantizerKBI, FixedPointQuantizerKIF
 
     internal_q: FixedPointQuantizerKIF | FixedPointQuantizerKBI = q.quantizer
 
     shape: tuple[int, ...] = tensor.shape[1:]  # type: ignore
     if any([s is None for s in shape]):
         raise ValueError(f"Tensor {tensor.name} has at least one dimension with no fixed size")
     k, i, f = internal_q.kif
-    k, B, I = k, k + i + f, k + i  # type: ignore
-    k, B, I = convert_to_numpy(k), convert_to_numpy(B), convert_to_numpy(I)
+    k, B, I = k, k + i + f, k + i  # type: ignore # noqa: E741
+    k, B, I = convert_to_numpy(k), convert_to_numpy(B), convert_to_numpy(I)  # noqa: E741
 
     k = np.broadcast_to(k.astype(np.int8), (1,) + shape)
     B = np.broadcast_to(B.astype(np.int8), (1,) + shape)
-    I = np.broadcast_to(I.astype(np.int8), (1,) + shape)
+    I = np.broadcast_to(I.astype(np.int8), (1,) + shape)  # noqa: E741
 
     overflow_mode = internal_q.overflow_mode
     round_mode = internal_q.round_mode
@@ -61,7 +61,7 @@ def override_io_tensor_confs(confs: tuple[dict[str, Any], ...], overrides: dict[
 class SQLayerHandler(KerasV3LayerHandler):
     def __call__(
         self,
-        layer: 'squark.layers.QLayerBase',
+        layer: 'hgq.layers.QLayerBase',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):
@@ -108,18 +108,18 @@ def load_weight(self, layer: 'Layer', key: str):
 @register
 class SQEinsumDenseHandler(SQLayerHandler, KV3EinsumDenseHandler):
     handles = (
-        'squark.layers.core.einsum_dense.QEinsumDense',
-        'squark.layers.einsum_dense_batchnorm.QEinsumDenseBatchnorm',
+        'hgq.layers.core.einsum_dense.QEinsumDense',
+        'hgq.layers.einsum_dense_batchnorm.QEinsumDenseBatchnorm',
     )
 
 
 @register
 class SQStandaloneQuantizerHandler(KerasV3LayerHandler):
-    handles = ('squark.quantizer.quantizer.Quantizer',)
+    handles = ('hgq.quantizer.quantizer.Quantizer',)
 
     def handle(
         self,
-        layer: 'squark.quantizer.Quantizer',
+        layer: 'hgq.quantizer.Quantizer',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):
@@ -131,19 +131,19 @@ def handle(
 @register
 class SQConvHandler(SQLayerHandler, KV3ConvHandler):
     handles = (
-        'squark.layers.conv.QConv1D',
-        'squark.layers.conv.QConv2D',
-        # 'squark.layers.conv.QConv3D',
+        'hgq.layers.conv.QConv1D',
+        'hgq.layers.conv.QConv2D',
+        # 'hgq.layers.conv.QConv3D',
     )
 
 
 @register
 class SQDenseHandler(SQLayerHandler, KV3DenseHandler):
-    handles = ('squark.layers.core.dense.QDense', 'squark.layers.core.dense.QBatchNormDense')
+    handles = ('hgq.layers.core.dense.QDense', 'hgq.layers.core.dense.QBatchNormDense')
 
     def handle(
         self,
-        layer: 'squark.layers.QDense',
+        layer: 'hgq.layers.QDense',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):
@@ -161,16 +161,16 @@ def handle(
 
 @register
 class SQActivationHandler(SQLayerHandler, KV3ActivationHandler):
-    handles = ('squark.layers.activation.QActivation',)
+    handles = ('hgq.layers.activation.QActivation',)
 
 
 @register
 class SQBatchNormalizationHandler(SQLayerHandler):
-    handles = ('squark.layers.batch_normalization.QBatchNormalization',)
+    handles = ('hgq.layers.batch_normalization.QBatchNormalization',)
 
     def handle(
         self,
-        layer: 'squark.layers.QBatchNormalization',
+        layer: 'hgq.layers.QBatchNormalization',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):
@@ -193,18 +193,18 @@ def handle(
 @register
 class SQMergeHandler(SQLayerHandler, KV3MergeHandler):
     handles = (
-        'squark.layers.ops.merge.QAdd',
-        'squark.layers.ops.merge.QSubtract',
-        'squark.layers.ops.merge.QMultiply',
-        'squark.layers.ops.merge.QAverage',
-        'squark.layers.ops.merge.QMaximum',
-        'squark.layers.ops.merge.QMinimum',
-        'squark.layers.ops.merge.QConcatenate',
+        'hgq.layers.ops.merge.QAdd',
+        'hgq.layers.ops.merge.QSubtract',
+        'hgq.layers.ops.merge.QMultiply',
+        'hgq.layers.ops.merge.QAverage',
+        'hgq.layers.ops.merge.QMaximum',
+        'hgq.layers.ops.merge.QMinimum',
+        'hgq.layers.ops.merge.QConcatenate',
     )
 
     def handle(
         self,
-        layer: 'squark.layers.ops.merge.QMerge',
+        layer: 'hgq.layers.ops.merge.QMerge',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):

hls4ml/converters/keras_v3/squark/_base.py renamed to hls4ml/converters/keras_v3/hgq2/_base.py

@@ -5,17 +5,17 @@
 from ._base import SQLayerHandler, register
 
 if typing.TYPE_CHECKING:
-    import squark
+    import hgq
     from keras.api import KerasTensor
 
 
 @register
 class SQEinsumHandler(SQLayerHandler):
-    handles = ('squark.layers.ops.einsum.QEinsum',)
+    handles = ('hgq.layers.ops.einsum.QEinsum',)
 
     def handle(
         self,
-        layer: 'squark.layers.QEinsum',
+        layer: 'hgq.layers.QEinsum',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):

hls4ml/converters/keras_v3/squark/einsum.py renamed to hls4ml/converters/keras_v3/hgq2/einsum.py

@@ -9,22 +9,22 @@
 from .softmax import SQSoftmaxHandler
 
 if typing.TYPE_CHECKING:
-    import squark
+    import hgq
     from keras.api import KerasTensor
 
 
 @register
 class SQMultiHeadAttentionHandler(SQLayerHandler):
-    handles = ('squark.layers.multi_head_attention.QMultiHeadAttention',)
+    handles = ('hgq.layers.multi_head_attention.QMultiHeadAttention',)
 
     def handle(
         self,
-        layer: 'squark.layers.QMultiHeadAttention',
+        layer: 'hgq.layers.QMultiHeadAttention',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):
+        from hgq.layers import QEinsum
         from keras import KerasTensor
-        from squark.layers import QEinsum
 
         assert len(in_tensors) in (3, 4), 'MultiHead layer must have 3 (Q, K, V) or 4 (Q, K, V, M) input tensors'
         assert len(out_tensors) == 1, 'Attention score output is not supported yet'

hls4ml/converters/keras_v3/squark/multi_head_attention.py renamed to hls4ml/converters/keras_v3/hgq2/multi_head_attention.py

@@ -7,9 +7,9 @@
 from ._base import SQLayerHandler, register
 
 if typing.TYPE_CHECKING:
-    import squark
+    import hgq
+    from hgq.quantizer.internal import FixedPointQuantizerBase
     from keras.api import KerasTensor
-    from squark.quantizer.internal import FixedPointQuantizerBase
 
 
 def fixed_quantizer_to_hls4ml_t(q: 'FixedPointQuantizerBase', take_max=False):
@@ -40,11 +40,11 @@ def fixed_quantizer_to_hls4ml_t(q: 'FixedPointQuantizerBase', take_max=False):
 
 @register
 class SQSoftmaxHandler(SQLayerHandler):
-    handles = ('squark.layers.softmax.QSoftmax',)
+    handles = ('hgq.layers.softmax.QSoftmax',)
 
     def handle(
         self,
-        layer: 'squark.layers.QSoftmax',
+        layer: 'hgq.layers.QSoftmax',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):
@@ -66,8 +66,8 @@ def handle(
             n_in: int = prod(in_tensors[0].shape[axs[0] : axs[-1] + 1])  # type: ignore
             ax = -1  # if n_inner == 1 else 999  # 999 as placeholder
 
+        from hgq.quantizer.internal import FixedPointQuantizerBase
         from keras import ops
-        from squark.quantizer.internal import FixedPointQuantizerBase
 
         impl = 'stable' if layer.stable else 'latency'
 

hls4ml/converters/keras_v3/squark/softmax.py renamed to hls4ml/converters/keras_v3/hgq2/softmax.py

@@ -9,7 +9,7 @@
 from ._base import KerasV3LayerHandler, SQLayerHandler, register
 
 if typing.TYPE_CHECKING:
-    import squark
+    import hgq
     from keras.api import KerasTensor
 
 from decimal import Decimal
@@ -19,16 +19,16 @@
 
 @register
 class SQUnaryLUTHandler(SQLayerHandler, KerasV3LayerHandler):
-    handles = ('squark.layers.activation.QUnaryFunctionLUT',)
+    handles = ('hgq.layers.activation.QUnaryFunctionLUT',)
 
     def handle(
         self,
-        layer: 'squark.layers.QUnaryFunctionLUT',
+        layer: 'hgq.layers.QUnaryFunctionLUT',
         in_tensors: Sequence['KerasTensor'],
         out_tensors: Sequence['KerasTensor'],
     ):
+        from hgq.quantizer.internal import FixedPointQuantizerBase, FloatPointQuantizer
         from keras import ops
-        from squark.quantizer.internal import FixedPointQuantizerBase, FloatPointQuantizer
 
         if not layer.enable_iq and not layer.enable_oq:
             raise ValueError('Currently only support input_quantizer enabled UnaryFunctionLUT layer')

hls4ml/converters/keras_v3/squark/unary_lut.py renamed to hls4ml/converters/keras_v3/hgq2/unary_lut.py

@@ -11,8 +11,8 @@
     pytest.skip('Only keras v3 is supported for now', allow_module_level=True)
 
 try:
-    from squark.layers import QEinsum
-    from squark.utils import trace_mode
+    from hgq.layers import QEinsum
+    from hgq.utils import trace_mode
 except ImportError:
     pytest.skip('s-quark is not installed', allow_module_level=True)