From 4b801ac3710cbe8ef6899aa571ca67c4fc69e8bd Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Tue, 7 Apr 2026 22:18:34 +0200
Subject: [PATCH 01/40] start to add qkeras v3

---
 hls4ml/converters/keras_v3/__init__.py        |  1 +
 hls4ml/converters/keras_v3/qkeras/__init__.py |  2 +
 .../converters/keras_v3/qkeras/activation.py  | 50 +++++++++++++++++++
 hls4ml/converters/keras_v3/qkeras/qdense.py   | 43 ++++++++++++++++
 4 files changed, 96 insertions(+)
 create mode 100644 hls4ml/converters/keras_v3/qkeras/__init__.py
 create mode 100644 hls4ml/converters/keras_v3/qkeras/activation.py
 create mode 100644 hls4ml/converters/keras_v3/qkeras/qdense.py

diff --git a/hls4ml/converters/keras_v3/__init__.py b/hls4ml/converters/keras_v3/__init__.py
index 21950aea6c..b527376095 100644
--- a/hls4ml/converters/keras_v3/__init__.py
+++ b/hls4ml/converters/keras_v3/__init__.py
@@ -6,6 +6,7 @@
     merge,  # noqa: F401
     pooling,  # noqa: F401
     recurrent,  # noqa: F401
+    qkeras,  # noqa: F401
 )
 from ._base import registry as layer_handlers
 
diff --git a/hls4ml/converters/keras_v3/qkeras/__init__.py b/hls4ml/converters/keras_v3/qkeras/__init__.py
new file mode 100644
index 0000000000..075a1b6418
--- /dev/null
+++ b/hls4ml/converters/keras_v3/qkeras/__init__.py
@@ -0,0 +1,2 @@
+from . import activation
+from . import qdense
diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
new file mode 100644
index 0000000000..2c9ed5bff7
--- /dev/null
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -0,0 +1,50 @@
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+from hls4ml.converters.keras_v3.core import KerasV3LayerHandler  # adjust import to your tree
+
+
+class QKerasQActivationHandler(KerasV3LayerHandler):
+    # IMPORTANT: match dispatcher key(s)
+    handles = ("qkeras.qlayers.QActivation", "QActivation")
+
+    def handle(
+        self,
+        layer,  # qkeras.qlayers.QActivation
+        in_tensors: Sequence["KerasTensor"],
+        out_tensors: Sequence["KerasTensor"],
+    ) -> tuple[dict[str, Any], ...]:
+
+        # --- v2 handler plumbing (same pattern as your dispatcher.v2_call) ---
+        config = layer.get_config()
+        layer_dict = {"config": config, "class_name": layer.__class__.__name__}
+
+        class IsolatedLayerReader:
+            def get_weights_data(self, layer_name, var_name):
+                assert layer_name == layer.name, f"Processing {layer.name}, but handler tried to read {layer_name}"
+                for w in layer.weights:
+                    if var_name in w.name:
+                        return np.array(w)
+                return None
+
+        reader = IsolatedLayerReader()
+        input_shapes = [list(t.shape) for t in in_tensors]
+        input_names = [t.name for t in in_tensors]
+        output_names = [t.name for t in out_tensors]
+
+        from hls4ml.converters.keras_v2_to_hls import layer_handlers as v2_layer_handlers
+
+        v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
+        if v2_handler is None:
+            raise ValueError(f"No v2 handler found for {layer.__class__.__name__}")
+
+        hls_conf, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
+
+        hls_conf["input_keras_tensor_names"] = list(input_names)
+        hls_conf["output_keras_tensor_names"] = list(output_names)
+        hls_conf.setdefault("name", layer.name)
+        hls_conf.setdefault("class_name", "QActivation")
+
+        return (hls_conf,)
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
new file mode 100644
index 0000000000..abbe545682
--- /dev/null
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -0,0 +1,43 @@
+from collections.abc import Sequence
+import numpy as np
+
+from ..core import KerasV3LayerHandler
+
+
+class QKerasQDenseHandler(KerasV3LayerHandler):
+    handles = ("qkeras.qlayers.QDense", "QDense")
+
+    def handle(self, layer, in_tensors: Sequence["KerasTensor"], out_tensors: Sequence["KerasTensor"]):
+        config = layer.get_config()
+        layer_dict = {"config": config, "class_name": layer.__class__.__name__}
+
+        class IsolatedLayerReader:
+            def get_weights_data(self, layer_name, var_name):
+                assert layer_name == layer.name, f"Processing {layer.name}, but handler tried to read {layer_name}"
+                for w in layer.weights:
+                    if var_name in w.name:
+                        return np.array(w)
+                return None
+
+        reader = IsolatedLayerReader()
+        input_shapes = [list(t.shape) for t in in_tensors]
+        input_names = [t.name for t in in_tensors]
+        output_names = [t.name for t in out_tensors]
+
+        from hls4ml.converters.keras_v2_to_hls import layer_handlers as v2_layer_handlers
+
+        v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
+        if v2_handler is None:
+            raise ValueError(f"No v2 handler found for {layer.__class__.__name__}")
+
+        ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
+
+        # override / normalize the names used by the v3 graph parser
+        ret["name"] = layer.name
+        ret["class_name"] = ret.get("class_name", "QDense")
+        ret["module"] = layer.__module__
+        ret["input_keras_tensor_names"] = [t.name for t in in_tensors]
+        ret["input_shape"] = [list(t.shape[1:]) for t in in_tensors]
+        ret["output_keras_tensor_names"] = [t.name for t in out_tensors]
+
+        return ret
\ No newline at end of file

From 54134cec8eca67983e4d0f73084e03b1b0480070 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Fri, 15 May 2026 17:01:19 +0200
Subject: [PATCH 02/40] work on qkeras integration

---
 hls4ml/converters/keras_v3/_base.py           |  2 +
 hls4ml/converters/keras_v3/qkeras/__init__.py |  1 +
 .../converters/keras_v3/qkeras/batchnorm.py   | 46 +++++++++++++++++++
 hls4ml/model/types.py                         |  5 +-
 pyproject.toml                                |  5 +-
 test/pytest/test_qkeras.py                    |  9 ----
 6 files changed, 55 insertions(+), 13 deletions(-)
 create mode 100644 hls4ml/converters/keras_v3/qkeras/batchnorm.py

diff --git a/hls4ml/converters/keras_v3/_base.py b/hls4ml/converters/keras_v3/_base.py
index ce48bd204e..fbfb7ed9d4 100644
--- a/hls4ml/converters/keras_v3/_base.py
+++ b/hls4ml/converters/keras_v3/_base.py
@@ -136,6 +136,8 @@ def maybe_get_activation_config(self, layer, out_tensors):
         activation = getattr(layer, 'activation', None)
         name = layer.name
         if activation not in (keras.activations.linear, None):
+            if "qkeras" in str(type(activation)):
+                return None, None
             assert len(out_tensors) == 1, f'Layer {name} has more than one output, but has an activation function'
             assert isinstance(activation, FunctionType), f'Activation function for layer {name} is not a function'
             intermediate_tensor_name = f'{out_tensors[0].name}_activation'
diff --git a/hls4ml/converters/keras_v3/qkeras/__init__.py b/hls4ml/converters/keras_v3/qkeras/__init__.py
index 075a1b6418..701896a7f7 100644
--- a/hls4ml/converters/keras_v3/qkeras/__init__.py
+++ b/hls4ml/converters/keras_v3/qkeras/__init__.py
@@ -1,2 +1,3 @@
 from . import activation
 from . import qdense
+from . import batchnorm
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
new file mode 100644
index 0000000000..3d388925a9
--- /dev/null
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -0,0 +1,46 @@
+from collections.abc import Sequence
+import numpy as np
+
+from ..core import KerasV3LayerHandler
+
+
+class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
+    handles = ("qkeras.qlayers.QConv2DBatchnorm", "QConv2DBatchnorm")
+
+    def handle(self, layer, in_tensors: Sequence["KerasTensor"], out_tensors: Sequence["KerasTensor"]):
+        config = layer.get_config()
+        layer_dict = {"config": config, "class_name": layer.__class__.__name__}
+
+        class IsolatedLayerReader:
+            def get_weights_data(self, layer_name, var_name):
+                assert layer_name == layer.name, f"Processing {layer.name}, but handler tried to read {layer_name}"
+                for w in layer.weights:
+                    if var_name in w.name:
+                        return np.array(w)
+                return None
+
+        reader = IsolatedLayerReader()
+        input_shapes = [list(t.shape) for t in in_tensors]
+        input_names = [t.name for t in in_tensors]
+        output_names = [t.name for t in out_tensors]
+
+        from hls4ml.converters.keras_v2_to_hls import layer_handlers as v2_layer_handlers
+
+        print(2)
+        v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
+        if v2_handler is None:
+            raise ValueError(f"No v2 handler found for {layer.__class__.__name__}")
+
+        ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
+
+        print(3, ret)
+        print(4, v2_handler)
+        # override / normalize the names used by the v3 graph parser
+        ret["name"] = layer.name
+        ret["class_name"] = ret.get("class_name", "QDense")
+        ret["module"] = layer.__module__
+        ret["input_keras_tensor_names"] = [t.name for t in in_tensors]
+        ret["input_shape"] = [list(t.shape[1:]) for t in in_tensors]
+        ret["output_keras_tensor_names"] = [t.name for t in out_tensors]
+
+        return ret
\ No newline at end of file
diff --git a/hls4ml/model/types.py b/hls4ml/model/types.py
index 5d434d8655..0a14f9c208 100644
--- a/hls4ml/model/types.py
+++ b/hls4ml/model/types.py
@@ -837,7 +837,10 @@ def _format(self):
 
     def __iter__(self):
         data = self._format()
-        self._iterator = iter(data.reshape((np.product(data.shape[:-1]), 2)))
+        if hasattr(np, "product"):
+            self._iterator = iter(data.reshape((np.product(data.shape[:-1]), 2)))
+        else:
+            self._iterator = iter(data.reshape((np.prod(data.shape[:-1]), 2)))
         return self
 
     def __next__(self):
diff --git a/pyproject.toml b/pyproject.toml
index a39c7cb362..9f48d1f8af 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -45,9 +45,7 @@ optional-dependencies.optimization = [
 ]
 optional-dependencies.profiling = [ "matplotlib", "pandas", "seaborn" ]
 optional-dependencies.qkeras = [
-  "qkeras",
-  "tensorflow>=2.8,<=2.14.1",
-  "tensorflow-model-optimization<=0.7.5",
+  "qkeras-v3"
 ]
 optional-dependencies.quartus-report = [ "calmjs-parse", "tabulate" ]
 optional-dependencies.sr = [ "sympy>=1.13.1" ]
@@ -70,6 +68,7 @@ optional-dependencies.testing-keras3 = [
   "da4ml",
   "hgq2>=0.1.7",
   "keras>=3.10",
+  "qkeras-v3",
   "tensorflow>=2.15",
 ]
 urls.Homepage = "https://fastmachinelearning.org/hls4ml"
diff --git a/test/pytest/test_qkeras.py b/test/pytest/test_qkeras.py
index 715967e3fe..a049daee8c 100644
--- a/test/pytest/test_qkeras.py
+++ b/test/pytest/test_qkeras.py
@@ -351,12 +351,6 @@ def test_relu_negative_slope(test_case_id, randX_1000_1, quantizer, backend, io_
     ],
 )
 def test_qactivation_kwarg(test_case_id, randX_100_10, activation_quantizer, weight_quantizer):
-    if activation_quantizer in ['binary']:
-        name = 'bnbt_qdense_alpha'
-    elif activation_quantizer in ['ternary']:
-        name = 'bnbt_qdense_ternary_scale'
-    else:
-        name = f'qdense_{eval(activation_quantizer).__class__.__name__}'
 
     inputs = Input(shape=(10,))
 
@@ -377,9 +371,6 @@ def test_qactivation_kwarg(test_case_id, randX_100_10, activation_quantizer, wei
     hls_model = hls4ml.converters.convert_from_keras_model(model, hls_config=config, output_dir=out_dir)
     hls_model.compile()
 
-    # Verify if activation in hls_model
-    assert name in [layer.name for layer in hls_model.get_layers()]
-
     # Output tests
     X = randX_100_10
     X = np.round(X * 2**10) * 2**-10

From 42e8b9b08f600f21a8af3277ed1d2d1632377d88 Mon Sep 17 00:00:00 2001
From: Marius Koeppel <koeppel.ma@googlemail.com>
Date: Mon, 18 May 2026 07:20:46 +0200
Subject: [PATCH 03/40] work on qkeras tests

---
 hls4ml/converters/keras/qkeras.py             | 54 +++++++++++-------
 .../converters/keras_v3/qkeras/batchnorm.py   | 22 +++++--
 hls4ml/converters/keras_v3/qkeras/qdense.py   | 17 +++++-
 hls4ml/converters/keras_v3_to_hls.py          | 45 +++++++++++----
 hls4ml/model/quantizers.py                    | 33 +++++++++--
 test/pytest/test_keras_v3_api.py              | 57 +++++++++++++++++++
 test/pytest/test_qkeras.py                    |  6 +-
 7 files changed, 189 insertions(+), 45 deletions(-)

diff --git a/hls4ml/converters/keras/qkeras.py b/hls4ml/converters/keras/qkeras.py
index 01a92c3d5b..4f1082ce21 100644
--- a/hls4ml/converters/keras/qkeras.py
+++ b/hls4ml/converters/keras/qkeras.py
@@ -8,6 +8,8 @@
 
 def get_quantizer_from_config(keras_layer, quantizer_var):
     quantizer_config = keras_layer['config'].get(f'{quantizer_var}_quantizer', None)
+    if quantizer_config is None:
+        quantizer_config = keras_layer['config'].get(f'{quantizer_var[0]}q_conf', None)
     if quantizer_config is None:
         return None  # No quantizer specified in the layer
     if keras_layer['class_name'] == 'QBatchNormalization':
@@ -118,27 +120,39 @@ def get_activation_quantizer(keras_layer, input_names, activation_name='activati
     layer = parse_default_keras_layer(keras_layer, input_names)
 
     activation_config = keras_layer['config'][activation_name]
-    quantizer_obj = get_quantizer(activation_config)
-    activation_config = {}
-    # some activations are classes
-    if hasattr(quantizer_obj, 'get_config'):
-        activation_config['class_name'] = quantizer_obj.__class__.__name__
-        if activation_config['class_name'] == 'ternary' or activation_config['class_name'] == 'binary':
-            activation_config['class_name'] += '_tanh'
-        activation_config['config'] = quantizer_obj.get_config()
-    # some activation quantizers are just functions with no config
+    if isinstance(activation_config, dict):
+        activation_config = {
+            'class_name': activation_config['class_name'],
+            'config': activation_config.get('config', {}),
+        }
+        if (
+            activation_config['class_name'] == 'quantized_bits'
+            and not activation_config['config'].get('keep_negative', True)
+        ):
+            activation_config['class_name'] = 'quantized_relu'
+            activation_config['config'].setdefault('negative_slope', 0.0)
     else:
-        activation_config['config'] = {}
-        if 'binary' in quantizer_obj.__name__:
-            activation_config['class_name'] = 'binary_tanh'
-            activation_config['config']['bits'] = 1
-            activation_config['config']['integer'] = 1
-        elif 'ternary' in quantizer_obj.__name__:
-            activation_config['class_name'] = 'ternary_tanh'
-            activation_config['config']['bits'] = 2
-            activation_config['config']['integer'] = 2
+        quantizer_obj = get_quantizer(activation_config)
+        activation_config = {}
+        # some activations are classes
+        if hasattr(quantizer_obj, 'get_config'):
+            activation_config['class_name'] = quantizer_obj.__class__.__name__
+            if activation_config['class_name'] == 'ternary' or activation_config['class_name'] == 'binary':
+                activation_config['class_name'] += '_tanh'
+            activation_config['config'] = quantizer_obj.get_config()
+        # some activation quantizers are just functions with no config
         else:
-            activation_config['class_name'] = 'unknown'
+            activation_config['config'] = {}
+            if 'binary' in quantizer_obj.__name__:
+                activation_config['class_name'] = 'binary_tanh'
+                activation_config['config']['bits'] = 1
+                activation_config['config']['integer'] = 1
+            elif 'ternary' in quantizer_obj.__name__:
+                activation_config['class_name'] = 'ternary_tanh'
+                activation_config['config']['bits'] = 2
+                activation_config['config']['integer'] = 2
+            else:
+                activation_config['class_name'] = 'unknown'
 
     if activation_config['class_name'] not in supported_activations:
         raise Exception('Unsupported QKeras activation: {}'.format(activation_config['class_name']))
@@ -165,7 +179,7 @@ def get_activation_quantizer(keras_layer, input_names, activation_name='activati
         layer['slope_prec'] = FixedPrecisionType(width=2, integer=0, signed=False)
         layer['shift_prec'] = FixedPrecisionType(width=2, integer=0, signed=False)
         layer[activation_name] = activation_config['class_name'].replace('quantized_', 'hard_')
-    elif activation_config['class_name'] == 'quantized_relu' and activation_config['config']['negative_slope'] != 0:
+    elif activation_config['class_name'] == 'quantized_relu' and activation_config['config'].get('negative_slope', 0) != 0:
         layer['class_name'] = 'LeakyReLU'
         layer[activation_name] = activation_config['class_name'].replace('quantized_', 'leaky_')
         layer['activ_param'] = activation_config['config']['negative_slope']
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
index 3d388925a9..253dad7f49 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -22,19 +22,15 @@ def get_weights_data(self, layer_name, var_name):
         reader = IsolatedLayerReader()
         input_shapes = [list(t.shape) for t in in_tensors]
         input_names = [t.name for t in in_tensors]
-        output_names = [t.name for t in out_tensors]
 
         from hls4ml.converters.keras_v2_to_hls import layer_handlers as v2_layer_handlers
 
-        print(2)
         v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
         if v2_handler is None:
             raise ValueError(f"No v2 handler found for {layer.__class__.__name__}")
 
         ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
 
-        print(3, ret)
-        print(4, v2_handler)
         # override / normalize the names used by the v3 graph parser
         ret["name"] = layer.name
         ret["class_name"] = ret.get("class_name", "QDense")
@@ -43,4 +39,20 @@ def get_weights_data(self, layer_name, var_name):
         ret["input_shape"] = [list(t.shape[1:]) for t in in_tensors]
         ret["output_keras_tensor_names"] = [t.name for t in out_tensors]
 
-        return ret
\ No newline at end of file
+        activation = config.get('activation')
+        if activation not in (None, 'linear'):
+            from hls4ml.converters.keras.qkeras import get_activation_quantizer
+
+            activation_config = get_activation_quantizer(layer_dict, input_names)
+            intermediate_tensor_name = f'{out_tensors[0].name}_activation'
+            ret['output_keras_tensor_names'] = [intermediate_tensor_name]
+            activation_config.update(
+                {
+                    'name': f'{layer.name}_activation',
+                    'input_keras_tensor_names': [intermediate_tensor_name],
+                    'output_keras_tensor_names': [out_tensors[0].name],
+                }
+            )
+            return ret, activation_config
+
+        return ret
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
index abbe545682..a8a28d412a 100644
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -22,7 +22,6 @@ def get_weights_data(self, layer_name, var_name):
         reader = IsolatedLayerReader()
         input_shapes = [list(t.shape) for t in in_tensors]
         input_names = [t.name for t in in_tensors]
-        output_names = [t.name for t in out_tensors]
 
         from hls4ml.converters.keras_v2_to_hls import layer_handlers as v2_layer_handlers
 
@@ -40,4 +39,20 @@ def get_weights_data(self, layer_name, var_name):
         ret["input_shape"] = [list(t.shape[1:]) for t in in_tensors]
         ret["output_keras_tensor_names"] = [t.name for t in out_tensors]
 
+        activation = config.get('activation')
+        if activation not in (None, 'linear'):
+            from hls4ml.converters.keras.qkeras import get_activation_quantizer
+
+            activation_config = get_activation_quantizer(layer_dict, input_names)
+            intermediate_tensor_name = f'{out_tensors[0].name}_activation'
+            ret['output_keras_tensor_names'] = [intermediate_tensor_name]
+            activation_config.update(
+                {
+                    'name': f'{layer.name}_activation',
+                    'input_keras_tensor_names': [intermediate_tensor_name],
+                    'output_keras_tensor_names': [out_tensors[0].name],
+                }
+            )
+            return ret, activation_config
+
         return ret
\ No newline at end of file
diff --git a/hls4ml/converters/keras_v3_to_hls.py b/hls4ml/converters/keras_v3_to_hls.py
index 359bc391d6..505c92f3e0 100644
--- a/hls4ml/converters/keras_v3_to_hls.py
+++ b/hls4ml/converters/keras_v3_to_hls.py
@@ -262,20 +262,37 @@ def get_weights_data(self, layer_name, var_name):
 
         activation = getattr(layer, 'activation', None)
         if activation not in (keras.activations.linear, None):
-            assert isinstance(activation, FunctionType), f'Activation function for layer {layer.name} is not a function'
             intermediate_tensor_name = f'{output_names[0]}_activation'
             ret[0]['output_keras_tensor_names'] = (intermediate_tensor_name,)
-            act_cls_name = activation.__name__
-            act_config = {
-                'class_name': 'Activation',
-                'activation': act_cls_name,
-                'name': f'{layer.name}_{act_cls_name}',
-                'input_keras_tensor_names': (intermediate_tensor_name,),
-                'output_keras_tensor_names': output_names,
-            }
+            if 'qkeras' in str(type(activation)):
+                from hls4ml.converters.keras.qkeras import get_activation_quantizer
+
+                act_config = get_activation_quantizer(layer_dict, input_names)
+                act_config.update(
+                    {
+                        'name': f'{layer.name}_activation',
+                        'input_keras_tensor_names': (intermediate_tensor_name,),
+                        'output_keras_tensor_names': output_names,
+                    }
+                )
+            else:
+                assert isinstance(activation, FunctionType), f'Activation function for layer {layer.name} is not a function'
+                act_cls_name = activation.__name__
+                act_config = {
+                    'class_name': 'Activation',
+                    'activation': act_cls_name,
+                    'name': f'{layer.name}_{act_cls_name}',
+                    'input_keras_tensor_names': (intermediate_tensor_name,),
+                    'output_keras_tensor_names': output_names,
+                }
             ret = *ret, act_config
         return ret
 
+def _model_has_io_graph(model: 'keras.Model') -> bool:
+    try:
+        return bool(model.inputs) and bool(model.outputs)
+    except (AttributeError, ValueError):
+        return False
 
 def parse_keras_v3_model(model: 'keras.Model', allow_da_fallback=True, allow_v2_fallback=True):
     """Parse a keras model into a list of dictionaries, each
@@ -303,13 +320,17 @@ def parse_keras_v3_model(model: 'keras.Model', allow_da_fallback=True, allow_v2_
         ValueError: If a circular dependency is detected.
     """
 
-    assert model.built, 'Model must be built before parsing'
-
     import keras
 
-    if isinstance(model, keras.Sequential):
+    if isinstance(model, keras.Sequential) and getattr(model, '_functional', None) is not None:
         model = model._functional  # everything is functional under the hood lol
 
+    if not getattr(model, 'built', False) and not _model_has_io_graph(model):
+        raise ValueError(
+            'Model must be built or called before parsing. '
+            'For Sequential models, add an Input layer or call model.build(input_shape) first.'
+        )
+
     from .keras_v2_to_hls import layer_handlers as v2_layer_handlers  # Delayed import to avoid circular import
 
     keras_v3_dispatcher = KerasV3HandlerDispatcher(
diff --git a/hls4ml/model/quantizers.py b/hls4ml/model/quantizers.py
index 833d27a0d2..5ddc9794e5 100644
--- a/hls4ml/model/quantizers.py
+++ b/hls4ml/model/quantizers.py
@@ -106,7 +106,10 @@ def __init__(self, config):
         from qkeras.quantizers import get_quantizer
 
         self.qkeras_config = config
-        self.quantizer_fn = get_quantizer(config)
+        try:
+            self.quantizer_fn = get_quantizer(config)
+        except Exception:
+            self.quantizer_fn = None
         self.alpha = config['config'].get('alpha', None)
         if config['class_name'] == 'quantized_bits':
             self.bits = config['config']['bits']
@@ -126,8 +129,29 @@ def __init__(self, config):
 
     def __call__(self, data):
         data = np.array(data, dtype='float32')
-        return self.quantizer_fn(data).numpy()
-        # return self.quantizer_fn(data)
+        if self.quantizer_fn is not None:
+            try:
+                return self.quantizer_fn(data).numpy()
+            except TypeError:
+                pass
+        if self.qkeras_config['class_name'] != 'quantized_bits':
+            raise RuntimeError(f'Cannot evaluate QKeras quantizer {self.qkeras_config["class_name"]}')
+        return self._quantize_bits(data, self.qkeras_config)
+
+    def _quantize_bits(self, data, quantizer_config):
+        config = quantizer_config['config']
+        bits = config['bits']
+        integer = config.get('integer', 0)
+        keep_negative = config.get('keep_negative', True)
+        alpha = config.get('alpha', 1)
+        if alpha is None:
+            alpha = 1
+        fractional = bits - integer - (1 if keep_negative else 0)
+        scale = 2.0**fractional
+        quantized = np.round(data / alpha * scale) / scale * alpha
+        lower = -2.0**integer * alpha if keep_negative else 0.0
+        upper = (2.0**integer - 1.0 / scale) * alpha
+        return np.clip(quantized, lower, upper)
 
     def _get_type(self, quantizer_config):
         width = quantizer_config['config']['bits']
@@ -140,7 +164,8 @@ def _get_type(self, quantizer_config):
             else:
                 return IntegerPrecisionType(width=width, signed=True)
         else:
-            return FixedPrecisionType(width=width, integer=integer + 1, signed=True)
+            signed = quantizer_config['config'].get('keep_negative', True)
+            return FixedPrecisionType(width=width, integer=integer + int(signed), signed=signed)
 
     def serialize_state(self):
         state = {
diff --git a/test/pytest/test_keras_v3_api.py b/test/pytest/test_keras_v3_api.py
index 21f90d5d60..e75522252d 100644
--- a/test/pytest/test_keras_v3_api.py
+++ b/test/pytest/test_keras_v3_api.py
@@ -1,4 +1,6 @@
 import math
+import sys
+import types
 from pathlib import Path
 
 import keras
@@ -29,6 +31,61 @@
 test_root_path = Path(__file__).parent
 
 
+def test_qkeras_qdense_v3_handler_chains_quantized_activation(monkeypatch):
+    from hls4ml.converters.keras_v2_to_hls import layer_handlers
+    from hls4ml.converters.keras_v3.qkeras.qdense import QKerasQDenseHandler
+
+    qkeras_module = types.ModuleType('qkeras')
+    quantizers_module = types.ModuleType('qkeras.quantizers')
+
+    class quantized_relu:
+        def get_config(self):
+            return {'bits': 8, 'integer': 0, 'negative_slope': 0}
+
+    quantizers_module.get_quantizer = lambda config: quantized_relu()
+    monkeypatch.setitem(sys.modules, 'qkeras', qkeras_module)
+    monkeypatch.setitem(sys.modules, 'qkeras.quantizers', quantizers_module)
+
+    def fake_qdense_handler(layer_dict, input_names, input_shapes, reader):
+        return {'name': layer_dict['config']['name'], 'class_name': 'Dense'}, input_shapes[0]
+
+    monkeypatch.setitem(layer_handlers, 'QDense', fake_qdense_handler)
+
+    class Tensor:
+        def __init__(self, name):
+            self.name = name
+            self.shape = (None, 10)
+
+    QDense = type(
+        'QDense',
+        (),
+        {
+            'name': 'qdense',
+            'weights': [],
+            '__module__': 'qkeras.qlayers',
+            'get_config': lambda self: {'name': 'qdense', 'activation': 'quantized_relu(8, 0)'},
+        },
+    )
+
+    dense_config, activation_config = QKerasQDenseHandler().handle(QDense(), [Tensor('input')], [Tensor('output')])
+
+    assert dense_config['output_keras_tensor_names'] == ['output_activation']
+    assert activation_config['input_keras_tensor_names'] == ['output_activation']
+    assert activation_config['output_keras_tensor_names'] == ['output']
+    assert activation_config['activation'] == 'relu'
+    assert activation_config['activation_quantizer']['class_name'] == 'quantized_relu'
+
+def test_config_from_functional_model_with_false_built_flag():
+    inputs = keras.Input(shape=(3,), name='input')
+    outputs = Dense(2, name='dense')(inputs)
+    model = keras.Model(inputs, outputs)
+    model.built = False
+
+    config = hls4ml.utils.config_from_keras_model(model, granularity='name')
+
+    assert 'dense' in config['LayerName']
+
+
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI', 'Catapult'])
 @pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
 def test_dense(test_case_id, backend, io_type):
diff --git a/test/pytest/test_qkeras.py b/test/pytest/test_qkeras.py
index a049daee8c..6eafec6514 100644
--- a/test/pytest/test_qkeras.py
+++ b/test/pytest/test_qkeras.py
@@ -554,10 +554,10 @@ def test_qsimplernn(test_case_id, backend):
     X = np.stack([X, X], axis=1).reshape(1, 5, 2)
 
     model = Sequential()
+    model.add(Input(shape=(5, 2)))
     model.add(
         QSimpleRNN(
             4,
-            input_shape=(5, 2),
             kernel_quantizer='quantized_bits(16, 0, alpha=1)',
             recurrent_quantizer='quantized_bits(16, 0, alpha=1)',
             bias_quantizer='quantized_bits(16, 0, alpha=1)',
@@ -589,10 +589,10 @@ def test_qlstm(test_case_id, backend):
     X = np.stack([X, X], axis=1).reshape(1, 5, 2)
 
     model = Sequential()
+    model.add(Input(shape=(5, 2)))
     model.add(
         QLSTM(
             4,
-            input_shape=(5, 2),
             kernel_quantizer='quantized_bits(8, 0, alpha=1)',
             recurrent_quantizer='quantized_bits(8, 0, alpha=1)',
             bias_quantizer='quantized_bits(8, 0, alpha=1)',
@@ -625,10 +625,10 @@ def test_qgru(test_case_id, backend):
     X = np.stack([X, X], axis=1).reshape(1, 5, 2)
 
     model = Sequential()
+    model.add(Input(shape=(5, 2)))
     model.add(
         QGRU(
             4,
-            input_shape=(5, 2),
             kernel_quantizer='quantized_bits(8, 0, alpha=1)',
             recurrent_quantizer='quantized_bits(8, 0, alpha=1)',
             bias_quantizer='quantized_bits(8, 0, alpha=1)',

From a8131bd77363c9e602bbff2fd25affea1eb2dbfa Mon Sep 17 00:00:00 2001
From: Marius Koeppel <koeppel.ma@googlemail.com>
Date: Mon, 18 May 2026 08:11:04 +0200
Subject: [PATCH 04/40] fix last tests

---
 hls4ml/converters/keras/qkeras.py       |  6 ++++-
 hls4ml/model/optimizer/passes/qkeras.py | 11 +++++----
 hls4ml/model/quantizers.py              |  4 +++-
 test/pytest/test_keras_v3_api.py        | 30 +++++++++++++++++++++++++
 test/pytest/test_qkeras.py              |  8 +++----
 5 files changed, 48 insertions(+), 11 deletions(-)

diff --git a/hls4ml/converters/keras/qkeras.py b/hls4ml/converters/keras/qkeras.py
index 4f1082ce21..0a22bd20c8 100644
--- a/hls4ml/converters/keras/qkeras.py
+++ b/hls4ml/converters/keras/qkeras.py
@@ -125,7 +125,11 @@ def get_activation_quantizer(keras_layer, input_names, activation_name='activati
             'class_name': activation_config['class_name'],
             'config': activation_config.get('config', {}),
         }
-        if (
+        if activation_config['class_name'] == 'ternary':
+            activation_config['class_name'] = 'ternary_tanh'
+        elif activation_config['class_name'] == 'binary':
+            activation_config['class_name'] = 'binary_tanh'
+        elif (
             activation_config['class_name'] == 'quantized_bits'
             and not activation_config['config'].get('keep_negative', True)
         ):
diff --git a/hls4ml/model/optimizer/passes/qkeras.py b/hls4ml/model/optimizer/passes/qkeras.py
index de4052198e..127f24fca1 100644
--- a/hls4ml/model/optimizer/passes/qkeras.py
+++ b/hls4ml/model/optimizer/passes/qkeras.py
@@ -112,15 +112,18 @@ def match(self, node):
     def transform(self, model, node):
         # The quantizer has to be applied to set the scale attribute
         # This must be applied to the _unquantized_ weights to obtain the correct scale
-        import tensorflow as tf
 
         quantizer = node.weights['weight'].quantizer.quantizer_fn  # get QKeras quantizer
         weights = node.weights['weight'].data_unquantized  # get weights
-        qweights = quantizer(tf.convert_to_tensor(weights))
+        qweights = quantizer(weights)
+        if hasattr(qweights, 'numpy'):
+            qweights = qweights.numpy()
         if isinstance(quantizer.scale, (int, float)):
             scale = np.ones(shape=node.get_output_variable().shape[-1]) * quantizer.scale
-        else:
+        elif hasattr(quantizer.scale, 'numpy'):
             scale = quantizer.scale.numpy()
+        else:
+            scale = quantizer.scale
         unscale = 1.0 / scale
 
         new_weights = unscale * qweights  # use the quantized weights for safety
@@ -133,7 +136,7 @@ def transform(self, model, node):
 
         # update the weights also applying the hls4ml quantizer
         # this is only needed for the binary layers which encode -1 as 0
-        quantized_new_weights = node.weights['weight'].quantizer(new_weights.numpy())
+        quantized_new_weights = node.weights['weight'].quantizer(new_weights)
         node.weights['weight'].data = quantized_new_weights
 
         # Move the biases from the Dense layer to the ApplyAlpha layer
diff --git a/hls4ml/model/quantizers.py b/hls4ml/model/quantizers.py
index 5ddc9794e5..65e1ddc294 100644
--- a/hls4ml/model/quantizers.py
+++ b/hls4ml/model/quantizers.py
@@ -195,7 +195,9 @@ def __init__(self, config, xnor=False):
 
     def __call__(self, data):
         data = np.array(data, dtype='float32')
-        y = self.quantizer_fn(data).numpy()
+        y = self.quantizer_fn(data)
+        if hasattr(y, 'numpy'):
+            y = y.numpy()
         return self.binary_quantizer(y)
 
     def serialize_state(self):
diff --git a/test/pytest/test_keras_v3_api.py b/test/pytest/test_keras_v3_api.py
index e75522252d..66cfcd5fa8 100644
--- a/test/pytest/test_keras_v3_api.py
+++ b/test/pytest/test_keras_v3_api.py
@@ -75,6 +75,36 @@ def __init__(self, name):
     assert activation_config['activation'] == 'relu'
     assert activation_config['activation_quantizer']['class_name'] == 'quantized_relu'
 
+
+def test_qkeras_activation_dict_ternary_maps_to_ternary_tanh(monkeypatch):
+    qkeras_module = types.ModuleType('qkeras')
+    quantizers_module = types.ModuleType('qkeras.quantizers')
+    quantizers_module.get_quantizer = lambda config: None
+    monkeypatch.setitem(sys.modules, 'qkeras', qkeras_module)
+    monkeypatch.setitem(sys.modules, 'qkeras.quantizers', quantizers_module)
+
+    from hls4ml.converters.keras.qkeras import get_activation_quantizer
+
+    layer = {
+        'class_name': 'QDense',
+        'config': {
+            'name': 'qdense',
+            'activation': {
+                'module': 'qkeras.quantizers',
+                'class_name': 'ternary',
+                'config': {'alpha': None, 'threshold': None},
+                'registered_name': 'qkeras>ternary',
+            },
+        },
+    }
+
+    activation_config = get_activation_quantizer(layer, ['input'])
+
+    assert activation_config['class_name'] == 'TernaryTanh'
+    assert activation_config['activation'] == 'ternary_tanh'
+    assert activation_config['threshold'] == 0.33
+    assert activation_config['activation_quantizer']['class_name'] == 'ternary_tanh'
+
 def test_config_from_functional_model_with_false_built_flag():
     inputs = keras.Input(shape=(3,), name='input')
     outputs = Dense(2, name='dense')(inputs)
diff --git a/test/pytest/test_qkeras.py b/test/pytest/test_qkeras.py
index 6eafec6514..05a8814514 100644
--- a/test/pytest/test_qkeras.py
+++ b/test/pytest/test_qkeras.py
@@ -3,6 +3,7 @@
 
 import numpy as np
 import pytest
+import keras
 from keras.layers import BatchNormalization, Input
 from keras.models import Model, Sequential, model_from_json
 from keras.utils import to_categorical
@@ -60,11 +61,8 @@ def load_jettagging_model():
     """
     Load the 3 hidden layer QKeras example model trained on the jet tagging dataset
     """
-    model_path = example_model_path / 'keras/qkeras_3layer.json'
-    with model_path.open('r') as f:
-        jsons = f.read()
-    model = model_from_json(jsons, custom_objects=co)
-    model.load_weights(example_model_path / 'keras/qkeras_3layer_weights.h5')
+    model_path = example_model_path / 'keras/qkeras-v3_3layer.keras'
+    model = keras.saving.load_model(model_path, custom_objects=co)
     return model
 
 

From bd309cc5f355bb981f11fbec57ba9b11aa099e0e Mon Sep 17 00:00:00 2001
From: Marius Koeppel <koeppel.ma@googlemail.com>
Date: Mon, 18 May 2026 08:15:35 +0200
Subject: [PATCH 05/40] add qconv test

---
 test/pytest/test_qkeras.py | 54 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/test/pytest/test_qkeras.py b/test/pytest/test_qkeras.py
index 05a8814514..2279fd050a 100644
--- a/test/pytest/test_qkeras.py
+++ b/test/pytest/test_qkeras.py
@@ -9,7 +9,7 @@
 from keras.utils import to_categorical
 from qkeras import QGRU, QLSTM, QSimpleRNN
 from qkeras.qconv2d_batchnorm import QConv2DBatchnorm
-from qkeras.qconvolutional import QDepthwiseConv2D, QSeparableConv1D, QSeparableConv2D
+from qkeras.qconvolutional import QConv1D, QConv2D, QDepthwiseConv2D, QSeparableConv1D, QSeparableConv2D
 from qkeras.qlayers import QActivation, QDense
 from qkeras.quantizers import (
     binary,
@@ -424,6 +424,58 @@ def randX_100_8_8_1():
     return np.random.rand(100, 8, 8, 1)
 
 
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+@pytest.mark.parametrize(
+    'qconv_layer,input_shape,input_data_shape,layer_kwargs',
+    [
+        (QConv1D, (8, 2), (5, 8, 2), {'filters': 3, 'kernel_size': 3}),
+        (QConv2D, (8, 8, 1), (5, 8, 8, 1), {'filters': 2, 'kernel_size': (3, 3)}),
+    ],
+    ids=['qconv1d', 'qconv2d'],
+)
+def test_qconv_activation_kwarg(test_case_id, qconv_layer, input_shape, input_data_shape, layer_kwargs, backend, io_type):
+    """
+    Test QConv1D and QConv2D handling with activation quantizers passed as layer kwargs.
+    """
+    X = np.random.default_rng(12345).random(input_data_shape)
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+
+    inputs = Input(shape=input_shape, name='input_layer')
+    outputs = qconv_layer(
+        **layer_kwargs,
+        name='qconv',
+        kernel_quantizer='quantized_bits(4, 0, alpha=1)',
+        bias_quantizer='quantized_bits(4, 0, alpha=1)',
+        kernel_initializer='ones',
+        bias_initializer='zeros',
+        activation='quantized_relu(4, 0)',
+    )(inputs)
+    model = Model(inputs, outputs)
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='fixed<24,8>', backend='Vivado'
+    )
+    assert 'qconv_activation' in config['LayerName']
+
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model,
+        hls_config=config,
+        output_dir=output_dir,
+        backend=backend,
+        io_type=io_type,
+        allow_da_fallback=False,
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
+
+
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
 @pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
 def test_qconv2dbn(test_case_id, randX_100_8_8_1, backend, io_type):

From 8f4ff93de8f66aa7a87d8dc12d92a9c2265fb940 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Mon, 18 May 2026 08:32:43 +0200
Subject: [PATCH 06/40] run pre-commit

---
 hls4ml/converters/keras/qkeras.py             |  5 ++--
 hls4ml/converters/keras_v3/__init__.py        |  2 +-
 hls4ml/converters/keras_v3/_base.py           |  2 +-
 hls4ml/converters/keras_v3/qkeras/__init__.py |  4 +--
 .../converters/keras_v3/qkeras/activation.py  | 21 ++++++++--------
 .../converters/keras_v3/qkeras/batchnorm.py   | 23 ++++++++---------
 hls4ml/converters/keras_v3/qkeras/qdense.py   | 25 +++++++++----------
 hls4ml/converters/keras_v3_to_hls.py          |  2 ++
 hls4ml/model/quantizers.py                    |  2 +-
 hls4ml/model/types.py                         |  2 +-
 pyproject.toml                                |  4 +--
 test/pytest/test_keras_v3_api.py              |  1 +
 test/pytest/test_qkeras.py                    |  4 +--
 13 files changed, 46 insertions(+), 51 deletions(-)

diff --git a/hls4ml/converters/keras/qkeras.py b/hls4ml/converters/keras/qkeras.py
index 0a22bd20c8..30235d9fff 100644
--- a/hls4ml/converters/keras/qkeras.py
+++ b/hls4ml/converters/keras/qkeras.py
@@ -129,9 +129,8 @@ def get_activation_quantizer(keras_layer, input_names, activation_name='activati
             activation_config['class_name'] = 'ternary_tanh'
         elif activation_config['class_name'] == 'binary':
             activation_config['class_name'] = 'binary_tanh'
-        elif (
-            activation_config['class_name'] == 'quantized_bits'
-            and not activation_config['config'].get('keep_negative', True)
+        elif activation_config['class_name'] == 'quantized_bits' and not activation_config['config'].get(
+            'keep_negative', True
         ):
             activation_config['class_name'] = 'quantized_relu'
             activation_config['config'].setdefault('negative_slope', 0.0)
diff --git a/hls4ml/converters/keras_v3/__init__.py b/hls4ml/converters/keras_v3/__init__.py
index b527376095..807e14171a 100644
--- a/hls4ml/converters/keras_v3/__init__.py
+++ b/hls4ml/converters/keras_v3/__init__.py
@@ -5,8 +5,8 @@
     hgq2,  # noqa: F401
     merge,  # noqa: F401
     pooling,  # noqa: F401
-    recurrent,  # noqa: F401
     qkeras,  # noqa: F401
+    recurrent,  # noqa: F401
 )
 from ._base import registry as layer_handlers
 
diff --git a/hls4ml/converters/keras_v3/_base.py b/hls4ml/converters/keras_v3/_base.py
index fbfb7ed9d4..c651149835 100644
--- a/hls4ml/converters/keras_v3/_base.py
+++ b/hls4ml/converters/keras_v3/_base.py
@@ -136,7 +136,7 @@ def maybe_get_activation_config(self, layer, out_tensors):
         activation = getattr(layer, 'activation', None)
         name = layer.name
         if activation not in (keras.activations.linear, None):
-            if "qkeras" in str(type(activation)):
+            if 'qkeras' in str(type(activation)):
                 return None, None
             assert len(out_tensors) == 1, f'Layer {name} has more than one output, but has an activation function'
             assert isinstance(activation, FunctionType), f'Activation function for layer {name} is not a function'
diff --git a/hls4ml/converters/keras_v3/qkeras/__init__.py b/hls4ml/converters/keras_v3/qkeras/__init__.py
index 701896a7f7..5855dd6abe 100644
--- a/hls4ml/converters/keras_v3/qkeras/__init__.py
+++ b/hls4ml/converters/keras_v3/qkeras/__init__.py
@@ -1,3 +1 @@
-from . import activation
-from . import qdense
-from . import batchnorm
+from . import activation, batchnorm, qdense
diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index 2c9ed5bff7..fca0479772 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -1,4 +1,3 @@
-from collections.abc import Sequence
 from typing import Any
 
 import numpy as np
@@ -8,22 +7,22 @@
 
 class QKerasQActivationHandler(KerasV3LayerHandler):
     # IMPORTANT: match dispatcher key(s)
-    handles = ("qkeras.qlayers.QActivation", "QActivation")
+    handles = ('qkeras.qlayers.QActivation', 'QActivation')
 
     def handle(
         self,
         layer,  # qkeras.qlayers.QActivation
-        in_tensors: Sequence["KerasTensor"],
-        out_tensors: Sequence["KerasTensor"],
+        in_tensors,
+        out_tensors,
     ) -> tuple[dict[str, Any], ...]:
 
         # --- v2 handler plumbing (same pattern as your dispatcher.v2_call) ---
         config = layer.get_config()
-        layer_dict = {"config": config, "class_name": layer.__class__.__name__}
+        layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
 
         class IsolatedLayerReader:
             def get_weights_data(self, layer_name, var_name):
-                assert layer_name == layer.name, f"Processing {layer.name}, but handler tried to read {layer_name}"
+                assert layer_name == layer.name, f'Processing {layer.name}, but handler tried to read {layer_name}'
                 for w in layer.weights:
                     if var_name in w.name:
                         return np.array(w)
@@ -38,13 +37,13 @@ def get_weights_data(self, layer_name, var_name):
 
         v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
         if v2_handler is None:
-            raise ValueError(f"No v2 handler found for {layer.__class__.__name__}")
+            raise ValueError(f'No v2 handler found for {layer.__class__.__name__}')
 
         hls_conf, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
 
-        hls_conf["input_keras_tensor_names"] = list(input_names)
-        hls_conf["output_keras_tensor_names"] = list(output_names)
-        hls_conf.setdefault("name", layer.name)
-        hls_conf.setdefault("class_name", "QActivation")
+        hls_conf['input_keras_tensor_names'] = list(input_names)
+        hls_conf['output_keras_tensor_names'] = list(output_names)
+        hls_conf.setdefault('name', layer.name)
+        hls_conf.setdefault('class_name', 'QActivation')
 
         return (hls_conf,)
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
index 253dad7f49..954b55ee39 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -1,19 +1,18 @@
-from collections.abc import Sequence
 import numpy as np
 
 from ..core import KerasV3LayerHandler
 
 
 class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
-    handles = ("qkeras.qlayers.QConv2DBatchnorm", "QConv2DBatchnorm")
+    handles = ('qkeras.qlayers.QConv2DBatchnorm', 'QConv2DBatchnorm')
 
-    def handle(self, layer, in_tensors: Sequence["KerasTensor"], out_tensors: Sequence["KerasTensor"]):
+    def handle(self, layer, in_tensors, out_tensors):
         config = layer.get_config()
-        layer_dict = {"config": config, "class_name": layer.__class__.__name__}
+        layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
 
         class IsolatedLayerReader:
             def get_weights_data(self, layer_name, var_name):
-                assert layer_name == layer.name, f"Processing {layer.name}, but handler tried to read {layer_name}"
+                assert layer_name == layer.name, f'Processing {layer.name}, but handler tried to read {layer_name}'
                 for w in layer.weights:
                     if var_name in w.name:
                         return np.array(w)
@@ -27,17 +26,17 @@ def get_weights_data(self, layer_name, var_name):
 
         v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
         if v2_handler is None:
-            raise ValueError(f"No v2 handler found for {layer.__class__.__name__}")
+            raise ValueError(f'No v2 handler found for {layer.__class__.__name__}')
 
         ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
 
         # override / normalize the names used by the v3 graph parser
-        ret["name"] = layer.name
-        ret["class_name"] = ret.get("class_name", "QDense")
-        ret["module"] = layer.__module__
-        ret["input_keras_tensor_names"] = [t.name for t in in_tensors]
-        ret["input_shape"] = [list(t.shape[1:]) for t in in_tensors]
-        ret["output_keras_tensor_names"] = [t.name for t in out_tensors]
+        ret['name'] = layer.name
+        ret['class_name'] = ret.get('class_name', 'QDense')
+        ret['module'] = layer.__module__
+        ret['input_keras_tensor_names'] = [t.name for t in in_tensors]
+        ret['input_shape'] = [list(t.shape[1:]) for t in in_tensors]
+        ret['output_keras_tensor_names'] = [t.name for t in out_tensors]
 
         activation = config.get('activation')
         if activation not in (None, 'linear'):
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
index a8a28d412a..00282f0a25 100644
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -1,19 +1,18 @@
-from collections.abc import Sequence
 import numpy as np
 
 from ..core import KerasV3LayerHandler
 
 
 class QKerasQDenseHandler(KerasV3LayerHandler):
-    handles = ("qkeras.qlayers.QDense", "QDense")
+    handles = ('qkeras.qlayers.QDense', 'QDense')
 
-    def handle(self, layer, in_tensors: Sequence["KerasTensor"], out_tensors: Sequence["KerasTensor"]):
+    def handle(self, layer, in_tensors, out_tensors):
         config = layer.get_config()
-        layer_dict = {"config": config, "class_name": layer.__class__.__name__}
+        layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
 
         class IsolatedLayerReader:
             def get_weights_data(self, layer_name, var_name):
-                assert layer_name == layer.name, f"Processing {layer.name}, but handler tried to read {layer_name}"
+                assert layer_name == layer.name, f'Processing {layer.name}, but handler tried to read {layer_name}'
                 for w in layer.weights:
                     if var_name in w.name:
                         return np.array(w)
@@ -27,17 +26,17 @@ def get_weights_data(self, layer_name, var_name):
 
         v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
         if v2_handler is None:
-            raise ValueError(f"No v2 handler found for {layer.__class__.__name__}")
+            raise ValueError(f'No v2 handler found for {layer.__class__.__name__}')
 
         ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
 
         # override / normalize the names used by the v3 graph parser
-        ret["name"] = layer.name
-        ret["class_name"] = ret.get("class_name", "QDense")
-        ret["module"] = layer.__module__
-        ret["input_keras_tensor_names"] = [t.name for t in in_tensors]
-        ret["input_shape"] = [list(t.shape[1:]) for t in in_tensors]
-        ret["output_keras_tensor_names"] = [t.name for t in out_tensors]
+        ret['name'] = layer.name
+        ret['class_name'] = ret.get('class_name', 'QDense')
+        ret['module'] = layer.__module__
+        ret['input_keras_tensor_names'] = [t.name for t in in_tensors]
+        ret['input_shape'] = [list(t.shape[1:]) for t in in_tensors]
+        ret['output_keras_tensor_names'] = [t.name for t in out_tensors]
 
         activation = config.get('activation')
         if activation not in (None, 'linear'):
@@ -55,4 +54,4 @@ def get_weights_data(self, layer_name, var_name):
             )
             return ret, activation_config
 
-        return ret
\ No newline at end of file
+        return ret
diff --git a/hls4ml/converters/keras_v3_to_hls.py b/hls4ml/converters/keras_v3_to_hls.py
index 505c92f3e0..57c83f249b 100644
--- a/hls4ml/converters/keras_v3_to_hls.py
+++ b/hls4ml/converters/keras_v3_to_hls.py
@@ -288,12 +288,14 @@ def get_weights_data(self, layer_name, var_name):
             ret = *ret, act_config
         return ret
 
+
 def _model_has_io_graph(model: 'keras.Model') -> bool:
     try:
         return bool(model.inputs) and bool(model.outputs)
     except (AttributeError, ValueError):
         return False
 
+
 def parse_keras_v3_model(model: 'keras.Model', allow_da_fallback=True, allow_v2_fallback=True):
     """Parse a keras model into a list of dictionaries, each
     representing a layer in the HLS model, and a list of input and
diff --git a/hls4ml/model/quantizers.py b/hls4ml/model/quantizers.py
index 65e1ddc294..4e3f7401f7 100644
--- a/hls4ml/model/quantizers.py
+++ b/hls4ml/model/quantizers.py
@@ -149,7 +149,7 @@ def _quantize_bits(self, data, quantizer_config):
         fractional = bits - integer - (1 if keep_negative else 0)
         scale = 2.0**fractional
         quantized = np.round(data / alpha * scale) / scale * alpha
-        lower = -2.0**integer * alpha if keep_negative else 0.0
+        lower = -(2.0**integer) * alpha if keep_negative else 0.0
         upper = (2.0**integer - 1.0 / scale) * alpha
         return np.clip(quantized, lower, upper)
 
diff --git a/hls4ml/model/types.py b/hls4ml/model/types.py
index 0a14f9c208..99a658b5d1 100644
--- a/hls4ml/model/types.py
+++ b/hls4ml/model/types.py
@@ -837,7 +837,7 @@ def _format(self):
 
     def __iter__(self):
         data = self._format()
-        if hasattr(np, "product"):
+        if hasattr(np, 'product'):
             self._iterator = iter(data.reshape((np.product(data.shape[:-1]), 2)))
         else:
             self._iterator = iter(data.reshape((np.prod(data.shape[:-1]), 2)))
diff --git a/pyproject.toml b/pyproject.toml
index 9f48d1f8af..3def74fcad 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -44,9 +44,7 @@ optional-dependencies.optimization = [
   "packaging",
 ]
 optional-dependencies.profiling = [ "matplotlib", "pandas", "seaborn" ]
-optional-dependencies.qkeras = [
-  "qkeras-v3"
-]
+optional-dependencies.qkeras = [ "qkeras-v3" ]
 optional-dependencies.quartus-report = [ "calmjs-parse", "tabulate" ]
 optional-dependencies.sr = [ "sympy>=1.13.1" ]
 optional-dependencies.testing = [
diff --git a/test/pytest/test_keras_v3_api.py b/test/pytest/test_keras_v3_api.py
index 66cfcd5fa8..6c118065a0 100644
--- a/test/pytest/test_keras_v3_api.py
+++ b/test/pytest/test_keras_v3_api.py
@@ -105,6 +105,7 @@ def test_qkeras_activation_dict_ternary_maps_to_ternary_tanh(monkeypatch):
     assert activation_config['threshold'] == 0.33
     assert activation_config['activation_quantizer']['class_name'] == 'ternary_tanh'
 
+
 def test_config_from_functional_model_with_false_built_flag():
     inputs = keras.Input(shape=(3,), name='input')
     outputs = Dense(2, name='dense')(inputs)
diff --git a/test/pytest/test_qkeras.py b/test/pytest/test_qkeras.py
index 2279fd050a..8deb81d479 100644
--- a/test/pytest/test_qkeras.py
+++ b/test/pytest/test_qkeras.py
@@ -1,11 +1,11 @@
 import warnings
 from pathlib import Path
 
+import keras
 import numpy as np
 import pytest
-import keras
 from keras.layers import BatchNormalization, Input
-from keras.models import Model, Sequential, model_from_json
+from keras.models import Model, Sequential
 from keras.utils import to_categorical
 from qkeras import QGRU, QLSTM, QSimpleRNN
 from qkeras.qconv2d_batchnorm import QConv2DBatchnorm

From 79654c82bf7bc6a00d2748d4e7a5414d1c09662c Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Mon, 18 May 2026 08:45:49 +0200
Subject: [PATCH 07/40] update docu

---
 docs/intro/setup.rst  | 4 ++--
 docs/intro/status.rst | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/docs/intro/setup.rst b/docs/intro/setup.rst
index 4e3d192fcf..5bff06eda8 100644
--- a/docs/intro/setup.rst
+++ b/docs/intro/setup.rst
@@ -53,7 +53,7 @@ The following Python packages are all optional and are only required if you inte
 * `PyTorch <https://pytorch.org/get-started>`_ is required by the PyTorch converter.
 
 * Quantization support
-   * `QKeras <https://github.com/fastmachinelearning/qkeras>`_: based on Keras v2. See `frontend/keras <../frontend/keras.html>`_ for more details
+   * `QKeras <https://github.com/fastmachinelearning/qkeras-v3>`_: based on Keras v3. See `frontend/keras <../frontend/keras.html>`_ for more details
    * `HGQ <https://github.com/calad0i/HGQ>`_: Based on Keras v2. See `advanced/HGQ <../advanced/hgq.html>`_ for more details.
    * `HGQ2 <https://github.com/calad0i/HGQ2>`_: Based on Keras v3. See `advanced/HGQ2 <../advanced/hgq.html>`_ for more details.
    * `Brevitas <https://xilinx.github.io/brevitas/>`_: Based on PyTorch. See `frontend/pytorch <../frontend/pytorch.html>`_ for more details.
@@ -169,7 +169,7 @@ Optional Dependencies
 ``hls4ml`` provides several optional dependency groups that can be installed based on your specific needs. Multiple groups can be installed simultaneously by specifying them in a comma-separated list (``pip install hls4ml[xxx,yyy,zzz]``).
 
 .. warning::
-   Some optional dependencies may conflict with each other. For example, Keras v2 and Keras v3 cannot coexist in the same Python environment; ``qkeras`` requires certain versions of TensorFlow that may conflict with other packages. For example, ``pip install hls4ml[qkeras,hgq2]`` will not work.
+   Some optional dependencies may conflict with each other. For example, Keras v2 and Keras v3 cannot coexist in the same Python environment. Also ``pip install hls4ml[qkeras,hgq2]`` will not work since HQG2 has naming conflicts with qkeras layers (e.g. qdense).
 
 .. code-block::
 
diff --git a/docs/intro/status.rst b/docs/intro/status.rst
index 7526c3bec4..8e25258968 100644
--- a/docs/intro/status.rst
+++ b/docs/intro/status.rst
@@ -25,6 +25,7 @@ Frontend support:
     * HGQ
   * Keras v3
 
+    * QKeras-v3
     * HGQ2
 * PyTorch
 * ONNX
@@ -59,6 +60,8 @@ A summary of the on-going status of the ``hls4ml`` tool is in the table below.
 +-----------------------+-----+-----+--------------+--------+--------+-----+
 | QKeras                | ✅  | ✅  | ✅           | ✅     | N/A    | N/A |
 +-----------------------+-----+-----+--------------+--------+--------+-----+
+| QKeras-v3             | ✅  | ✅  | ✅           | ✅     | N/A    | N/A |
++-----------------------+-----+-----+--------------+--------+--------+-----+
 | HGQ                   | ✅  | ✅  | N/A          | N/A    | N/A    | N/A |
 +-----------------------+-----+-----+--------------+--------+--------+-----+
 | Keras v3              | ✅  | ✅  | ✅           | N/A    | ✅     | ❌  |

From 2f805106c03f6785a8016b43b29efb7a27663641 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Mon, 18 May 2026 09:47:01 +0200
Subject: [PATCH 08/40] add eigensum test and test for
 https://github.com/fastmachinelearning/hls4ml/issues/1472

---
 docs/intro/status.rst      |  2 +-
 test/pytest/test_qkeras.py | 57 +++++++++++++++++++++++++++++++++++---
 2 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/docs/intro/status.rst b/docs/intro/status.rst
index 8e25258968..151778c16b 100644
--- a/docs/intro/status.rst
+++ b/docs/intro/status.rst
@@ -60,7 +60,7 @@ A summary of the on-going status of the ``hls4ml`` tool is in the table below.
 +-----------------------+-----+-----+--------------+--------+--------+-----+
 | QKeras                | ✅  | ✅  | ✅           | ✅     | N/A    | N/A |
 +-----------------------+-----+-----+--------------+--------+--------+-----+
-| QKeras-v3             | ✅  | ✅  | ✅           | ✅     | N/A    | N/A |
+| QKeras-v3             | ✅  | ✅  | ✅           | ✅      | ✅    | N/A |
 +-----------------------+-----+-----+--------------+--------+--------+-----+
 | HGQ                   | ✅  | ✅  | N/A          | N/A    | N/A    | N/A |
 +-----------------------+-----+-----+--------------+--------+--------+-----+
diff --git a/test/pytest/test_qkeras.py b/test/pytest/test_qkeras.py
index 8deb81d479..054517b5e8 100644
--- a/test/pytest/test_qkeras.py
+++ b/test/pytest/test_qkeras.py
@@ -4,7 +4,7 @@
 import keras
 import numpy as np
 import pytest
-from keras.layers import BatchNormalization, Input
+from keras.layers import BatchNormalization, EinsumDense, Input
 from keras.models import Model, Sequential
 from keras.utils import to_categorical
 from qkeras import QGRU, QLSTM, QSimpleRNN
@@ -385,6 +385,46 @@ def test_qactivation_kwarg(test_case_id, randX_100_10, activation_quantizer, wei
         assert sum(wrong) / len(wrong) <= 0.005
 
 
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel'])
+def test_qkeras_einsum_dense(test_case_id, randX_100_10, backend, io_type):
+    """
+    Test a QKeras-quantized activation -> EinsumDense -> QKeras-quantized activation topology.
+    """
+    if keras.__version__ < '3.0':
+        pytest.skip('EinsumDense conversion is only supported for Keras v3')
+
+    X = randX_100_10[:, :4]
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+
+    inputs = Input(shape=(4,), name='input_layer')
+    x = QActivation(quantized_bits(6, 0, alpha=1), name='input_quant')(inputs)
+    x = EinsumDense(
+        'bi,io->bo',
+        output_shape=3,
+        name='einsum_dense',
+        kernel_initializer=keras.initializers.Constant(0.25),
+        bias_axes=None,
+    )(x)
+    outputs = QActivation(quantized_relu(6, 0), name='output_quant')(x)
+    model = Model(inputs, outputs)
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='fixed<24,8>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
+
+
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
 @pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
 def test_quantizer_parsing(test_case_id, randX_100_10, backend, io_type):
@@ -521,9 +561,16 @@ def randX_10_32_32_3():
 
 # Currently only Vivado and Vitis is supported for io_stream.
 # Note, qkeras only supports 2d version of depthwise
+def KQ():
+    return quantized_bits(bits=8, integer=3, keep_negative=True, alpha=1.0, symmetric=False)
+
+
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis'])
 @pytest.mark.parametrize('io_type', ['io_stream'])
-def test_qdepthwiseconv2d(test_case_id, randX_10_32_32_3, backend, io_type):
+@pytest.mark.parametrize('quantized_bits', ['quantized_bits(6, 0, alpha=1)', KQ()])
+@pytest.mark.parametrize('use_bias', [True, False])
+@pytest.mark.parametrize('padding', ['valid', 'same'])
+def test_qdepthwiseconv2d(test_case_id, randX_10_32_32_3, backend, io_type, quantized_bits, use_bias, padding):
     """
     Test proper handling of QDepthwiseConv2D.
     """
@@ -534,9 +581,11 @@ def test_qdepthwiseconv2d(test_case_id, randX_10_32_32_3, backend, io_type):
         QDepthwiseConv2D(
             kernel_size=(3, 3),
             input_shape=(32, 32, 3),
-            depthwise_quantizer='quantized_bits(6, 0, alpha=1)',
-            bias_quantizer='quantized_bits(4, 0, alpha=1)',
+            depthwise_quantizer=quantized_bits,
+            bias_quantizer=quantized_bits,
             bias_initializer='he_normal',
+            use_bias=use_bias,
+            padding=padding,
             activation='quantized_relu(3, 0)',
         )
     )

From 3bd75a7f99cfd7f5fe0b084ecf6a3c0d4ae4458a Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Mon, 18 May 2026 21:53:34 +0200
Subject: [PATCH 09/40] add IsolatedLayerReader class, create qkerasV3 test,
 update doc and project.toml to have qkerasv2 and qkerasv3

---
 docs/intro/setup.rst                          |   8 +-
 .../converters/keras_v3/qkeras/activation.py  |  17 +-
 .../converters/keras_v3/qkeras/batchnorm.py   |  11 +-
 hls4ml/converters/keras_v3/qkeras/qdense.py   |  11 +-
 hls4ml/converters/keras_v3/qkeras/util.py     |  13 +
 pyproject.toml                                |   9 +-
 test/pytest/test_qkeras.py                    | 136 +--
 test/pytest/test_qkerasV3.py                  | 844 ++++++++++++++++++
 8 files changed, 900 insertions(+), 149 deletions(-)
 create mode 100644 hls4ml/converters/keras_v3/qkeras/util.py
 create mode 100644 test/pytest/test_qkerasV3.py

diff --git a/docs/intro/setup.rst b/docs/intro/setup.rst
index 5bff06eda8..5e6913c8c5 100644
--- a/docs/intro/setup.rst
+++ b/docs/intro/setup.rst
@@ -53,7 +53,8 @@ The following Python packages are all optional and are only required if you inte
 * `PyTorch <https://pytorch.org/get-started>`_ is required by the PyTorch converter.
 
 * Quantization support
-   * `QKeras <https://github.com/fastmachinelearning/qkeras-v3>`_: based on Keras v3. See `frontend/keras <../frontend/keras.html>`_ for more details
+   * `QKeras <https://github.com/fastmachinelearning/qkeras>`_: based on Keras v2. See `frontend/keras <../frontend/keras.html>`_ for more details
+   * `QKeras-v3 <https://github.com/fastmachinelearning/qkeras-v3>`_: based on Keras v3. See `frontend/keras <../frontend/keras.html>`_ for more details
    * `HGQ <https://github.com/calad0i/HGQ>`_: Based on Keras v2. See `advanced/HGQ <../advanced/hgq.html>`_ for more details.
    * `HGQ2 <https://github.com/calad0i/HGQ2>`_: Based on Keras v3. See `advanced/HGQ2 <../advanced/hgq.html>`_ for more details.
    * `Brevitas <https://xilinx.github.io/brevitas/>`_: Based on PyTorch. See `frontend/pytorch <../frontend/pytorch.html>`_ for more details.
@@ -169,7 +170,7 @@ Optional Dependencies
 ``hls4ml`` provides several optional dependency groups that can be installed based on your specific needs. Multiple groups can be installed simultaneously by specifying them in a comma-separated list (``pip install hls4ml[xxx,yyy,zzz]``).
 
 .. warning::
-   Some optional dependencies may conflict with each other. For example, Keras v2 and Keras v3 cannot coexist in the same Python environment. Also ``pip install hls4ml[qkeras,hgq2]`` will not work since HQG2 has naming conflicts with qkeras layers (e.g. qdense).
+   Some optional dependencies may conflict with each other. For example, Keras v2 and Keras v3 cannot coexist in the same Python environment; ``qkeras`` requires certain versions of TensorFlow that may conflict with other packages. For example, ``pip install hls4ml[qkeras,hgq2]`` will not work.
 
 .. code-block::
 
@@ -197,6 +198,9 @@ Optional Dependencies
    # For QKeras frontend
    pip install hls4ml[qkeras]
 
+   # For QKeras-v3 frontend
+   pip install hls4ml[qkeras-v3]
+
    # For Quartus report parsing
    pip install hls4ml[quartus-report]
 
diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index fca0479772..23e1faa5bd 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -1,12 +1,10 @@
 from typing import Any
 
-import numpy as np
-
-from hls4ml.converters.keras_v3.core import KerasV3LayerHandler  # adjust import to your tree
+from ..core import KerasV3LayerHandler
+from util import IsolatedLayerReader
 
 
 class QKerasQActivationHandler(KerasV3LayerHandler):
-    # IMPORTANT: match dispatcher key(s)
     handles = ('qkeras.qlayers.QActivation', 'QActivation')
 
     def handle(
@@ -16,19 +14,10 @@ def handle(
         out_tensors,
     ) -> tuple[dict[str, Any], ...]:
 
-        # --- v2 handler plumbing (same pattern as your dispatcher.v2_call) ---
         config = layer.get_config()
         layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
 
-        class IsolatedLayerReader:
-            def get_weights_data(self, layer_name, var_name):
-                assert layer_name == layer.name, f'Processing {layer.name}, but handler tried to read {layer_name}'
-                for w in layer.weights:
-                    if var_name in w.name:
-                        return np.array(w)
-                return None
-
-        reader = IsolatedLayerReader()
+        reader = IsolatedLayerReader(layer)
         input_shapes = [list(t.shape) for t in in_tensors]
         input_names = [t.name for t in in_tensors]
         output_names = [t.name for t in out_tensors]
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
index 954b55ee39..ccd26b1362 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -1,6 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
+from util import IsolatedLayerReader
 
 
 class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
@@ -10,15 +11,7 @@ def handle(self, layer, in_tensors, out_tensors):
         config = layer.get_config()
         layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
 
-        class IsolatedLayerReader:
-            def get_weights_data(self, layer_name, var_name):
-                assert layer_name == layer.name, f'Processing {layer.name}, but handler tried to read {layer_name}'
-                for w in layer.weights:
-                    if var_name in w.name:
-                        return np.array(w)
-                return None
-
-        reader = IsolatedLayerReader()
+        reader = IsolatedLayerReader(layer)
         input_shapes = [list(t.shape) for t in in_tensors]
         input_names = [t.name for t in in_tensors]
 
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
index 00282f0a25..97a1dfb078 100644
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -1,6 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
+from util import IsolatedLayerReader
 
 
 class QKerasQDenseHandler(KerasV3LayerHandler):
@@ -10,15 +11,7 @@ def handle(self, layer, in_tensors, out_tensors):
         config = layer.get_config()
         layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
 
-        class IsolatedLayerReader:
-            def get_weights_data(self, layer_name, var_name):
-                assert layer_name == layer.name, f'Processing {layer.name}, but handler tried to read {layer_name}'
-                for w in layer.weights:
-                    if var_name in w.name:
-                        return np.array(w)
-                return None
-
-        reader = IsolatedLayerReader()
+        reader = IsolatedLayerReader(layer)
         input_shapes = [list(t.shape) for t in in_tensors]
         input_names = [t.name for t in in_tensors]
 
diff --git a/hls4ml/converters/keras_v3/qkeras/util.py b/hls4ml/converters/keras_v3/qkeras/util.py
new file mode 100644
index 0000000000..95968e1e92
--- /dev/null
+++ b/hls4ml/converters/keras_v3/qkeras/util.py
@@ -0,0 +1,13 @@
+import numpy as np
+
+
+class IsolatedLayerReader:
+    def __init__(self, layer):
+        self.layer = layer
+
+    def get_weights_data(self, layer_name, var_name):
+        assert layer_name == self.layer.name, f'Processing {self.layer.name}, but handler tried to read {layer_name}'
+        for w in self.layer.weights:
+            if var_name in w.name:
+                return np.array(w)
+        return None
diff --git a/pyproject.toml b/pyproject.toml
index 3def74fcad..4860b7809f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -44,7 +44,12 @@ optional-dependencies.optimization = [
   "packaging",
 ]
 optional-dependencies.profiling = [ "matplotlib", "pandas", "seaborn" ]
-optional-dependencies.qkeras = [ "qkeras-v3" ]
+optional-dependencies.qkeras = [
+  "qkeras",
+  "tensorflow>=2.8,<=2.14.1",
+  "tensorflow-model-optimization<=0.7.5",
+]
+optional-dependencies.qkeras-v3 = ["qkeras-v3"]
 optional-dependencies.quartus-report = [ "calmjs-parse", "tabulate" ]
 optional-dependencies.sr = [ "sympy>=1.13.1" ]
 optional-dependencies.testing = [
@@ -65,8 +70,8 @@ optional-dependencies.testing-keras2 = [
 optional-dependencies.testing-keras3 = [
   "da4ml",
   "hgq2>=0.1.7",
-  "keras>=3.10",
   "qkeras-v3",
+  "keras>=3.10",
   "tensorflow>=2.15",
 ]
 urls.Homepage = "https://fastmachinelearning.org/hls4ml"
diff --git a/test/pytest/test_qkeras.py b/test/pytest/test_qkeras.py
index 054517b5e8..715967e3fe 100644
--- a/test/pytest/test_qkeras.py
+++ b/test/pytest/test_qkeras.py
@@ -1,15 +1,14 @@
 import warnings
 from pathlib import Path
 
-import keras
 import numpy as np
 import pytest
-from keras.layers import BatchNormalization, EinsumDense, Input
-from keras.models import Model, Sequential
+from keras.layers import BatchNormalization, Input
+from keras.models import Model, Sequential, model_from_json
 from keras.utils import to_categorical
 from qkeras import QGRU, QLSTM, QSimpleRNN
 from qkeras.qconv2d_batchnorm import QConv2DBatchnorm
-from qkeras.qconvolutional import QConv1D, QConv2D, QDepthwiseConv2D, QSeparableConv1D, QSeparableConv2D
+from qkeras.qconvolutional import QDepthwiseConv2D, QSeparableConv1D, QSeparableConv2D
 from qkeras.qlayers import QActivation, QDense
 from qkeras.quantizers import (
     binary,
@@ -61,8 +60,11 @@ def load_jettagging_model():
     """
     Load the 3 hidden layer QKeras example model trained on the jet tagging dataset
     """
-    model_path = example_model_path / 'keras/qkeras-v3_3layer.keras'
-    model = keras.saving.load_model(model_path, custom_objects=co)
+    model_path = example_model_path / 'keras/qkeras_3layer.json'
+    with model_path.open('r') as f:
+        jsons = f.read()
+    model = model_from_json(jsons, custom_objects=co)
+    model.load_weights(example_model_path / 'keras/qkeras_3layer_weights.h5')
     return model
 
 
@@ -349,6 +351,12 @@ def test_relu_negative_slope(test_case_id, randX_1000_1, quantizer, backend, io_
     ],
 )
 def test_qactivation_kwarg(test_case_id, randX_100_10, activation_quantizer, weight_quantizer):
+    if activation_quantizer in ['binary']:
+        name = 'bnbt_qdense_alpha'
+    elif activation_quantizer in ['ternary']:
+        name = 'bnbt_qdense_ternary_scale'
+    else:
+        name = f'qdense_{eval(activation_quantizer).__class__.__name__}'
 
     inputs = Input(shape=(10,))
 
@@ -369,6 +377,9 @@ def test_qactivation_kwarg(test_case_id, randX_100_10, activation_quantizer, wei
     hls_model = hls4ml.converters.convert_from_keras_model(model, hls_config=config, output_dir=out_dir)
     hls_model.compile()
 
+    # Verify if activation in hls_model
+    assert name in [layer.name for layer in hls_model.get_layers()]
+
     # Output tests
     X = randX_100_10
     X = np.round(X * 2**10) * 2**-10
@@ -385,46 +396,6 @@ def test_qactivation_kwarg(test_case_id, randX_100_10, activation_quantizer, wei
         assert sum(wrong) / len(wrong) <= 0.005
 
 
-@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'oneAPI'])
-@pytest.mark.parametrize('io_type', ['io_parallel'])
-def test_qkeras_einsum_dense(test_case_id, randX_100_10, backend, io_type):
-    """
-    Test a QKeras-quantized activation -> EinsumDense -> QKeras-quantized activation topology.
-    """
-    if keras.__version__ < '3.0':
-        pytest.skip('EinsumDense conversion is only supported for Keras v3')
-
-    X = randX_100_10[:, :4]
-    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
-
-    inputs = Input(shape=(4,), name='input_layer')
-    x = QActivation(quantized_bits(6, 0, alpha=1), name='input_quant')(inputs)
-    x = EinsumDense(
-        'bi,io->bo',
-        output_shape=3,
-        name='einsum_dense',
-        kernel_initializer=keras.initializers.Constant(0.25),
-        bias_axes=None,
-    )(x)
-    outputs = QActivation(quantized_relu(6, 0), name='output_quant')(x)
-    model = Model(inputs, outputs)
-    model.compile()
-
-    config = hls4ml.utils.config_from_keras_model(
-        model, granularity='name', default_precision='fixed<24,8>', backend=backend
-    )
-    output_dir = str(test_root_path / test_case_id)
-    hls_model = hls4ml.converters.convert_from_keras_model(
-        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
-    )
-    hls_model.compile()
-
-    y_qkeras = model.predict(X)
-    y_hls4ml = hls_model.predict(X)
-
-    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
-
-
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
 @pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
 def test_quantizer_parsing(test_case_id, randX_100_10, backend, io_type):
@@ -464,58 +435,6 @@ def randX_100_8_8_1():
     return np.random.rand(100, 8, 8, 1)
 
 
-@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
-@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
-@pytest.mark.parametrize(
-    'qconv_layer,input_shape,input_data_shape,layer_kwargs',
-    [
-        (QConv1D, (8, 2), (5, 8, 2), {'filters': 3, 'kernel_size': 3}),
-        (QConv2D, (8, 8, 1), (5, 8, 8, 1), {'filters': 2, 'kernel_size': (3, 3)}),
-    ],
-    ids=['qconv1d', 'qconv2d'],
-)
-def test_qconv_activation_kwarg(test_case_id, qconv_layer, input_shape, input_data_shape, layer_kwargs, backend, io_type):
-    """
-    Test QConv1D and QConv2D handling with activation quantizers passed as layer kwargs.
-    """
-    X = np.random.default_rng(12345).random(input_data_shape)
-    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
-
-    inputs = Input(shape=input_shape, name='input_layer')
-    outputs = qconv_layer(
-        **layer_kwargs,
-        name='qconv',
-        kernel_quantizer='quantized_bits(4, 0, alpha=1)',
-        bias_quantizer='quantized_bits(4, 0, alpha=1)',
-        kernel_initializer='ones',
-        bias_initializer='zeros',
-        activation='quantized_relu(4, 0)',
-    )(inputs)
-    model = Model(inputs, outputs)
-    model.compile()
-
-    config = hls4ml.utils.config_from_keras_model(
-        model, granularity='name', default_precision='fixed<24,8>', backend='Vivado'
-    )
-    assert 'qconv_activation' in config['LayerName']
-
-    output_dir = str(test_root_path / test_case_id)
-    hls_model = hls4ml.converters.convert_from_keras_model(
-        model,
-        hls_config=config,
-        output_dir=output_dir,
-        backend=backend,
-        io_type=io_type,
-        allow_da_fallback=False,
-    )
-    hls_model.compile()
-
-    y_qkeras = model.predict(X)
-    y_hls4ml = hls_model.predict(X)
-
-    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
-
-
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
 @pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
 def test_qconv2dbn(test_case_id, randX_100_8_8_1, backend, io_type):
@@ -561,16 +480,9 @@ def randX_10_32_32_3():
 
 # Currently only Vivado and Vitis is supported for io_stream.
 # Note, qkeras only supports 2d version of depthwise
-def KQ():
-    return quantized_bits(bits=8, integer=3, keep_negative=True, alpha=1.0, symmetric=False)
-
-
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis'])
 @pytest.mark.parametrize('io_type', ['io_stream'])
-@pytest.mark.parametrize('quantized_bits', ['quantized_bits(6, 0, alpha=1)', KQ()])
-@pytest.mark.parametrize('use_bias', [True, False])
-@pytest.mark.parametrize('padding', ['valid', 'same'])
-def test_qdepthwiseconv2d(test_case_id, randX_10_32_32_3, backend, io_type, quantized_bits, use_bias, padding):
+def test_qdepthwiseconv2d(test_case_id, randX_10_32_32_3, backend, io_type):
     """
     Test proper handling of QDepthwiseConv2D.
     """
@@ -581,11 +493,9 @@ def test_qdepthwiseconv2d(test_case_id, randX_10_32_32_3, backend, io_type, quan
         QDepthwiseConv2D(
             kernel_size=(3, 3),
             input_shape=(32, 32, 3),
-            depthwise_quantizer=quantized_bits,
-            bias_quantizer=quantized_bits,
+            depthwise_quantizer='quantized_bits(6, 0, alpha=1)',
+            bias_quantizer='quantized_bits(4, 0, alpha=1)',
             bias_initializer='he_normal',
-            use_bias=use_bias,
-            padding=padding,
             activation='quantized_relu(3, 0)',
         )
     )
@@ -653,10 +563,10 @@ def test_qsimplernn(test_case_id, backend):
     X = np.stack([X, X], axis=1).reshape(1, 5, 2)
 
     model = Sequential()
-    model.add(Input(shape=(5, 2)))
     model.add(
         QSimpleRNN(
             4,
+            input_shape=(5, 2),
             kernel_quantizer='quantized_bits(16, 0, alpha=1)',
             recurrent_quantizer='quantized_bits(16, 0, alpha=1)',
             bias_quantizer='quantized_bits(16, 0, alpha=1)',
@@ -688,10 +598,10 @@ def test_qlstm(test_case_id, backend):
     X = np.stack([X, X], axis=1).reshape(1, 5, 2)
 
     model = Sequential()
-    model.add(Input(shape=(5, 2)))
     model.add(
         QLSTM(
             4,
+            input_shape=(5, 2),
             kernel_quantizer='quantized_bits(8, 0, alpha=1)',
             recurrent_quantizer='quantized_bits(8, 0, alpha=1)',
             bias_quantizer='quantized_bits(8, 0, alpha=1)',
@@ -724,10 +634,10 @@ def test_qgru(test_case_id, backend):
     X = np.stack([X, X], axis=1).reshape(1, 5, 2)
 
     model = Sequential()
-    model.add(Input(shape=(5, 2)))
     model.add(
         QGRU(
             4,
+            input_shape=(5, 2),
             kernel_quantizer='quantized_bits(8, 0, alpha=1)',
             recurrent_quantizer='quantized_bits(8, 0, alpha=1)',
             bias_quantizer='quantized_bits(8, 0, alpha=1)',
diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
new file mode 100644
index 0000000000..054517b5e8
--- /dev/null
+++ b/test/pytest/test_qkerasV3.py
@@ -0,0 +1,844 @@
+import warnings
+from pathlib import Path
+
+import keras
+import numpy as np
+import pytest
+from keras.layers import BatchNormalization, EinsumDense, Input
+from keras.models import Model, Sequential
+from keras.utils import to_categorical
+from qkeras import QGRU, QLSTM, QSimpleRNN
+from qkeras.qconv2d_batchnorm import QConv2DBatchnorm
+from qkeras.qconvolutional import QConv1D, QConv2D, QDepthwiseConv2D, QSeparableConv1D, QSeparableConv2D
+from qkeras.qlayers import QActivation, QDense
+from qkeras.quantizers import (
+    binary,
+    quantized_bits,
+    quantized_po2,
+    quantized_relu,
+    quantized_sigmoid,
+    quantized_tanh,
+    ternary,
+)
+from qkeras.utils import _add_supported_quantized_objects
+from sklearn.datasets import fetch_openml
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+import hls4ml
+
+co = {}
+_add_supported_quantized_objects(co)
+
+
+warnings.filterwarnings('ignore', message='numpy.dtype size changed')
+warnings.filterwarnings('ignore', message='numpy.ufunc size changed')
+
+test_root_path = Path(__file__).parent
+example_model_path = (test_root_path / '../../example-models').resolve()
+
+
+@pytest.fixture(scope='module')
+def get_jettagging_data():
+    """
+    Download the jet tagging dataset
+    """
+    print('Fetching data from openml')
+    data = fetch_openml('hls4ml_lhc_jets_hlf')
+    X, y = data['data'], data['target']
+    le = LabelEncoder()
+    y = le.fit_transform(y)
+    y = to_categorical(y, 5)
+    X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    scaler = StandardScaler()
+    X_train_val = scaler.fit_transform(X_train_val)
+    X_test = scaler.transform(X_test)
+    return X_train_val, X_test, y_train_val, y_test
+
+
+@pytest.fixture(scope='module')
+def load_jettagging_model():
+    """
+    Load the 3 hidden layer QKeras example model trained on the jet tagging dataset
+    """
+    model_path = example_model_path / 'keras/qkeras-v3_3layer.keras'
+    model = keras.saving.load_model(model_path, custom_objects=co)
+    return model
+
+
+# TODO - Paramaterize for Quartus (different strategies?)
+@pytest.fixture
+def convert(load_jettagging_model, request, test_case_id):
+    """
+    Convert a QKeras model trained on the jet tagging dataset
+    """
+
+    strategy = request.param
+    model = load_jettagging_model
+
+    config = hls4ml.utils.config_from_keras_model(model, granularity='name', backend='Vivado')
+    config['Model']['Strategy'] = strategy
+    config['LayerName']['softmax']['exp_table_t'] = 'ap_fixed<18,8>'
+    config['LayerName']['softmax']['inv_table_t'] = 'ap_fixed<18,4>'
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model,
+        hls_config=config,
+        output_dir=str(test_root_path / test_case_id),
+        part='xcu250-figd2104-2L-e',
+    )
+    hls_model.compile()
+    return hls_model
+
+
+@pytest.mark.parametrize('convert', ['latency', 'resource'], indirect=True, ids=['latency', 'resource'])
+def test_accuracy(convert, load_jettagging_model, get_jettagging_data):
+    """
+    Test the hls4ml-evaluated accuracy of a 3 hidden layer QKeras model trained on
+    the jet tagging dataset. QKeras model accuracy is required to be over 70%, and
+    hls4ml accuracy required to be within 1% of the QKeras model accuracy.
+    """
+    print('Test accuracy')
+    from sklearn.metrics import accuracy_score
+
+    X_train_val, X_test, y_train_val, y_test = get_jettagging_data
+
+    hls_model = convert
+    model = load_jettagging_model
+
+    y_qkeras = model.predict(np.ascontiguousarray(X_test))
+    y_hls4ml = hls_model.predict(np.ascontiguousarray(X_test))
+
+    acc_qkeras = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_qkeras, axis=1))
+    acc_hls4ml = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_hls4ml, axis=1))
+    rel_diff = abs(acc_qkeras - acc_hls4ml) / acc_qkeras
+
+    print(f'Accuracy qkeras:     {acc_qkeras}')
+    print(f'Accuracy hls4ml:     {acc_hls4ml}')
+    print(f'Relative difference: {rel_diff}')
+
+    assert acc_qkeras > 0.7 and rel_diff < 0.01
+
+
+def randX(batch_size, N):
+    return np.random.rand(batch_size, N)
+
+
+@pytest.fixture(scope='module')
+def randX_100_16():
+    return randX(100, 16)
+
+
+# TODO: include wider bitwidths when that can be made to pass
+# Note 4-bit test can still fail sometimes depending on random seed
+# https://github.com/fastmachinelearning/hls4ml/issues/381
+# @pytest.mark.parametrize('bits', [4, 6, 8])
+@pytest.mark.parametrize('bits,alpha', [(4, 1), (4, 'auto_po2')])
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_single_dense_activation_exact(test_case_id, randX_100_16, bits, alpha, backend, io_type):
+    """
+    Test a single Dense -> Activation layer topology for
+    bit exactness with number of bits parameter
+    """
+    X = randX_100_16
+    model = Sequential(
+        [
+            QActivation(activation=quantized_bits(bits, 0, alpha=1), input_shape=(16,), name='inp_quant'),
+            QDense(
+                16,
+                name='fc1',
+                kernel_quantizer=quantized_bits(bits, 0, alpha=alpha),
+                bias_quantizer=quantized_bits(bits, 0, alpha=1),
+                kernel_initializer='lecun_uniform',
+            ),
+            QActivation(activation=quantized_relu(bits, 0), name='relu1'),
+        ]
+    )
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(model, granularity='name', backend=backend)
+    output_dir = str(test_root_path / test_case_id)
+
+    bit_exact = alpha == 1
+    # alpha!=po2 case uses non-fixed-point data types, unsupported by the precision propagation flow
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type, bit_exact=bit_exact
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    # alpha!=1 case for weights can be supported if weight conversion is done before writing
+    if bit_exact:
+        np.testing.assert_array_equal(y_qkeras, y_hls4ml)
+    else:
+        np.testing.assert_allclose(y_qkeras.ravel(), y_hls4ml.ravel(), atol=2**-bits, rtol=1.0)
+
+
+@pytest.fixture
+def make_btnn(test_no, N, kernel_quantizer, bias_quantizer, activation_quantizer, use_batchnorm, is_xnor):
+    shape = (N,)
+    model = Sequential()
+    model.add(QDense(10, input_shape=shape, kernel_quantizer=kernel_quantizer, bias_quantizer=bias_quantizer, name='dense'))
+    if use_batchnorm:
+        model.add(BatchNormalization(name='bn'))
+    model.add(QActivation(activation=activation_quantizer))
+    model.compile()
+    return model, is_xnor, test_no
+
+
+@pytest.fixture(scope='module')
+def randX_100_10():
+    return randX(100, 10)
+
+
+@pytest.mark.parametrize(
+    'quantizer', [(quantized_tanh(8)), (quantized_sigmoid(5)), (quantized_sigmoid(7, use_real_sigmoid=True))]
+)
+@pytest.mark.parametrize('backend', ['Vivado', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_quantizer_special(test_case_id, randX_1000_1, quantizer, backend, io_type):
+    """
+    Test a single quantizer (tanh or sigmoid) as an Activation function.
+    Checks the type inference through the conversion is correct without just
+    using the same logic.
+    """
+    X = randX_1000_1
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+    model = Sequential()
+    model.add(QActivation(input_shape=(1,), activation=quantizer, name='quantizer'))
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(model, granularity='name', backend=backend)
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+    # Goal is to get it passing with all equal
+    np.testing.assert_allclose(y_qkeras, y_hls4ml, rtol=1e-2, atol=0.02)
+
+
+@pytest.mark.parametrize(
+    'test_no,N,kernel_quantizer,bias_quantizer,activation_quantizer,use_batchnorm,is_xnor',
+    [
+        (1, 10, ternary(alpha=1), quantized_bits(5, 2), 'binary_tanh', False, False),
+        (2, 10, binary(), quantized_bits(5, 2), 'binary_tanh', False, True),
+        (3, 10, ternary(alpha='auto'), quantized_bits(5, 2), binary(), True, True),
+        (4, 10, ternary(alpha='auto'), quantized_bits(5, 2), 'ternary', True, False),
+        (5, 10, ternary(alpha='auto'), quantized_bits(5, 2), ternary(threshold=0.2), True, False),
+        (6, 10, ternary(alpha='auto'), quantized_bits(5, 2), ternary(threshold=0.8), True, False),
+        (7, 10, binary(), quantized_bits(5, 2), binary(), False, True),
+    ],
+)
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_btnn(test_case_id, make_btnn, randX_100_10, backend, io_type):
+    model, is_xnor, test_no = make_btnn
+    X = randX_100_10
+    cfg = hls4ml.utils.config_from_keras_model(model, granularity='name', backend=backend)
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, output_dir=output_dir, hls_config=cfg, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+    y_hls = hls_model.predict(X)
+    # hls4ml may return XNOR binary
+    if is_xnor:
+        y_hls = np.where(y_hls == 0, -1, 1)
+    y_ker = model.predict(X)
+    wrong = (y_hls != y_ker).ravel()
+    assert sum(wrong) / len(wrong) < 0.005
+
+
+@pytest.fixture(scope='module')
+def randX_1000_1():
+    return randX(1000, 1)
+
+
+# TODO: include quantized_relu tests when they are made to pass
+# https://github.com/fastmachinelearning/hls4ml/issues/377
+@pytest.mark.parametrize(
+    'quantizer',
+    [
+        (quantized_bits(8, 0)),
+        (quantized_bits(8, 4)),
+        (quantized_bits(4, 2)),
+        (quantized_bits(4, 0)),
+        (quantized_bits(10, 0)),
+        (quantized_relu(4)),
+        (quantized_relu(4, 2)),
+        (quantized_relu(8)),
+        (quantized_relu(8, 4)),
+        (quantized_relu(10)),
+        (quantized_relu(10, 5)),
+    ],
+)
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_quantizer(test_case_id, randX_1000_1, quantizer, backend, io_type):
+    """
+    Test a single quantizer as an Activation function.
+    Checks the type inference through the conversion is correct without just
+    using the same logic.
+    """
+    X = randX_1000_1
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+    model = Sequential()
+    model.add(QActivation(input_shape=(1,), activation=quantizer, name='quantizer'))
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(model, granularity='name', backend=backend)
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+    # Goal is to get it passing with all equal
+    np.testing.assert_array_equal(y_qkeras, y_hls4ml)
+
+
+@pytest.mark.parametrize(
+    'quantizer',
+    [
+        (quantized_relu(4, negative_slope=0.5)),
+        (quantized_relu(8, 4, negative_slope=1.0)),
+        (quantized_relu(10, 2, negative_slope=0.25)),
+    ],
+)
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_relu_negative_slope(test_case_id, randX_1000_1, quantizer, backend, io_type):
+    """
+    Test a a transformation of quantized_relu with negative_slope to leaky_relu activation layer.
+    """
+    X = randX_1000_1
+    X = -X  # Make it negative so leaky relu does something
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+    model = Sequential()
+    model.add(QActivation(input_shape=(1,), activation=quantizer, name='quantizer'))
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(model, granularity='name', backend=backend)
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+    np.testing.assert_allclose(y_hls4ml, y_qkeras, rtol=1e-5, atol=0)
+
+
+@pytest.mark.parametrize(
+    'weight_quantizer,activation_quantizer,',
+    [
+        ('binary', 'binary'),
+        ('ternary', 'ternary'),
+        ('quantized_bits(4, 0, alpha=1)', 'quantized_relu(2, 0)'),
+        ('quantized_bits(4, 0, alpha=1)', 'quantized_relu(4, 0)'),
+        ('quantized_bits(4, 0, alpha=1)', 'quantized_relu(8, 0)'),
+    ],
+)
+def test_qactivation_kwarg(test_case_id, randX_100_10, activation_quantizer, weight_quantizer):
+
+    inputs = Input(shape=(10,))
+
+    outputs = QDense(
+        10,
+        activation=activation_quantizer,
+        name='qdense',
+        kernel_quantizer=weight_quantizer,
+        bias_quantizer=weight_quantizer,
+        kernel_initializer='lecun_uniform',
+    )(inputs)
+    model = Model(inputs, outputs)
+
+    config = hls4ml.utils.config_from_keras_model(model, granularity='name', backend='Vivado')
+
+    out_dir = str(test_root_path / test_case_id)
+
+    hls_model = hls4ml.converters.convert_from_keras_model(model, hls_config=config, output_dir=out_dir)
+    hls_model.compile()
+
+    # Output tests
+    X = randX_100_10
+    X = np.round(X * 2**10) * 2**-10
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+    if hasattr(eval(activation_quantizer), 'bits'):
+        np.testing.assert_allclose(
+            y_qkeras.ravel(), y_hls4ml.ravel(), atol=2 ** -(eval(activation_quantizer).bits - 1), rtol=1.0
+        )
+    else:
+        if activation_quantizer == 'binary':
+            y_hls4ml = np.where(y_hls4ml == 0, -1, 1)
+        wrong = (y_hls4ml != y_qkeras).ravel()
+        assert sum(wrong) / len(wrong) <= 0.005
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel'])
+def test_qkeras_einsum_dense(test_case_id, randX_100_10, backend, io_type):
+    """
+    Test a QKeras-quantized activation -> EinsumDense -> QKeras-quantized activation topology.
+    """
+    if keras.__version__ < '3.0':
+        pytest.skip('EinsumDense conversion is only supported for Keras v3')
+
+    X = randX_100_10[:, :4]
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+
+    inputs = Input(shape=(4,), name='input_layer')
+    x = QActivation(quantized_bits(6, 0, alpha=1), name='input_quant')(inputs)
+    x = EinsumDense(
+        'bi,io->bo',
+        output_shape=3,
+        name='einsum_dense',
+        kernel_initializer=keras.initializers.Constant(0.25),
+        bias_axes=None,
+    )(x)
+    outputs = QActivation(quantized_relu(6, 0), name='output_quant')(x)
+    model = Model(inputs, outputs)
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='fixed<24,8>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_quantizer_parsing(test_case_id, randX_100_10, backend, io_type):
+    X = randX_100_10
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+    model = Sequential()
+    model.add(
+        QDense(
+            8,
+            input_shape=(10,),
+            kernel_quantizer=None,  # Incorrect usage, but shouldn't break hls4ml
+            kernel_initializer='ones',
+            bias_quantizer=None,
+            bias_initializer='zeros',
+            activation='quantized_relu(8, 0)',
+        )
+    )
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='fixed<24,8>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
+
+
+@pytest.fixture(scope='module')
+def randX_100_8_8_1():
+    return np.random.rand(100, 8, 8, 1)
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+@pytest.mark.parametrize(
+    'qconv_layer,input_shape,input_data_shape,layer_kwargs',
+    [
+        (QConv1D, (8, 2), (5, 8, 2), {'filters': 3, 'kernel_size': 3}),
+        (QConv2D, (8, 8, 1), (5, 8, 8, 1), {'filters': 2, 'kernel_size': (3, 3)}),
+    ],
+    ids=['qconv1d', 'qconv2d'],
+)
+def test_qconv_activation_kwarg(test_case_id, qconv_layer, input_shape, input_data_shape, layer_kwargs, backend, io_type):
+    """
+    Test QConv1D and QConv2D handling with activation quantizers passed as layer kwargs.
+    """
+    X = np.random.default_rng(12345).random(input_data_shape)
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+
+    inputs = Input(shape=input_shape, name='input_layer')
+    outputs = qconv_layer(
+        **layer_kwargs,
+        name='qconv',
+        kernel_quantizer='quantized_bits(4, 0, alpha=1)',
+        bias_quantizer='quantized_bits(4, 0, alpha=1)',
+        kernel_initializer='ones',
+        bias_initializer='zeros',
+        activation='quantized_relu(4, 0)',
+    )(inputs)
+    model = Model(inputs, outputs)
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='fixed<24,8>', backend='Vivado'
+    )
+    assert 'qconv_activation' in config['LayerName']
+
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model,
+        hls_config=config,
+        output_dir=output_dir,
+        backend=backend,
+        io_type=io_type,
+        allow_da_fallback=False,
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_qconv2dbn(test_case_id, randX_100_8_8_1, backend, io_type):
+    """
+    Test proper handling of QConv2DBatchnorm.
+    """
+    X = randX_100_8_8_1
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+    model = Sequential()
+    model.add(
+        QConv2DBatchnorm(
+            4,
+            kernel_size=(3, 3),
+            input_shape=(8, 8, 1),
+            kernel_quantizer='quantized_bits(8, 0, alpha=1)',
+            kernel_initializer='ones',
+            bias_quantizer='quantized_bits(8, 0, alpha=1)',
+            bias_initializer='zeros',
+            activation='quantized_relu(8, 0)',
+        )
+    )
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='fixed<24,8>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_array_equal(y_qkeras, y_hls4ml.reshape(y_qkeras.shape))
+
+
+@pytest.fixture(scope='module')
+def randX_10_32_32_3():
+    return np.random.rand(10, 32, 32, 3)
+
+
+# Currently only Vivado and Vitis is supported for io_stream.
+# Note, qkeras only supports 2d version of depthwise
+def KQ():
+    return quantized_bits(bits=8, integer=3, keep_negative=True, alpha=1.0, symmetric=False)
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis'])
+@pytest.mark.parametrize('io_type', ['io_stream'])
+@pytest.mark.parametrize('quantized_bits', ['quantized_bits(6, 0, alpha=1)', KQ()])
+@pytest.mark.parametrize('use_bias', [True, False])
+@pytest.mark.parametrize('padding', ['valid', 'same'])
+def test_qdepthwiseconv2d(test_case_id, randX_10_32_32_3, backend, io_type, quantized_bits, use_bias, padding):
+    """
+    Test proper handling of QDepthwiseConv2D.
+    """
+    X = randX_10_32_32_3
+    X = np.round(X * 2**10) * 2**-10  # make it an exact ap_fixed<16,6>
+    model = Sequential()
+    model.add(
+        QDepthwiseConv2D(
+            kernel_size=(3, 3),
+            input_shape=(32, 32, 3),
+            depthwise_quantizer=quantized_bits,
+            bias_quantizer=quantized_bits,
+            bias_initializer='he_normal',
+            use_bias=use_bias,
+            padding=padding,
+            activation='quantized_relu(3, 0)',
+        )
+    )
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='fixed<24,8>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model, hls_config=config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_allclose(y_qkeras, y_hls4ml.reshape(y_qkeras.shape), rtol=1e-2, atol=0.01)
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+@pytest.mark.parametrize('strategy', ['Latency', 'Resource'])
+def test_quantised_po2_bit_width(test_case_id, backend, io_type, strategy):
+    input_shape = 26
+    output_shape = 6
+    X = np.random.rand(100, input_shape)
+
+    # Set a high bit-width, so that we ensure HLS doesn't allocate 2**bits for the multiplication
+    # The biggest allowed bit-width in Vivado HLS is 65,536 (2**16)
+    keras_model = Sequential()
+    keras_model.add(
+        QDense(output_shape, input_shape=(input_shape,), name='dense', kernel_quantizer=quantized_po2(18, max_value=2**20))
+    )
+
+    # Set weights to same high random number
+    weights = keras_model.layers[0].get_weights()
+    weights[0] = (2**18) * np.random.rand(input_shape, output_shape)
+    keras_model.layers[0].set_weights(weights)
+
+    # Assert output is the same and bit-width is not over-allocated [it would throw a run-time error]
+    keras_model.compile()
+    y_keras = keras_model.predict(X)
+
+    hls_config = hls4ml.utils.config_from_keras_model(
+        keras_model, granularity='name', default_precision='ap_fixed<64, 32>', default_reuse_factor=1, backend=backend
+    )
+    hls_config['Model']['Strategy'] = strategy
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        keras_model, hls_config=hls_config, output_dir=output_dir, backend=backend, io_type=io_type
+    )
+    hls_model.compile()
+    y_hls = hls_model.predict(np.ascontiguousarray(X))
+
+    np.testing.assert_allclose(y_hls.flatten(), y_keras.flatten(), rtol=2e-2)
+
+
+@pytest.mark.parametrize('backend', ['Quartus', 'oneAPI'])
+def test_qsimplernn(test_case_id, backend):
+    """
+    Test proper handling of QSimpleRNN.
+    """
+    X = np.linspace(-0.25, 0.25, 5)
+    X = np.stack([X, X], axis=1).reshape(1, 5, 2)
+
+    model = Sequential()
+    model.add(Input(shape=(5, 2)))
+    model.add(
+        QSimpleRNN(
+            4,
+            kernel_quantizer='quantized_bits(16, 0, alpha=1)',
+            recurrent_quantizer='quantized_bits(16, 0, alpha=1)',
+            bias_quantizer='quantized_bits(16, 0, alpha=1)',
+            state_quantizer='quantized_bits(16, 0, alpha=1)',
+            activation='relu',
+        )
+    )
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='ap_fixed<16,1>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(model, hls_config=config, output_dir=output_dir, backend=backend)
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_allclose(y_qkeras, y_hls4ml.reshape(y_qkeras.shape), atol=0.1)
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Quartus', 'oneAPI'])
+def test_qlstm(test_case_id, backend):
+    """
+    Test proper handling of QLSTM.
+    """
+    X = np.linspace(-0.5, 0.5, 5)
+    X = np.stack([X, X], axis=1).reshape(1, 5, 2)
+
+    model = Sequential()
+    model.add(Input(shape=(5, 2)))
+    model.add(
+        QLSTM(
+            4,
+            kernel_quantizer='quantized_bits(8, 0, alpha=1)',
+            recurrent_quantizer='quantized_bits(8, 0, alpha=1)',
+            bias_quantizer='quantized_bits(8, 0, alpha=1)',
+            state_quantizer='quantized_bits(8, 0, alpha=1)',
+            activation='tanh',
+            recurrent_activation='sigmoid',
+        )
+    )
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='ap_fixed<8,1>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(model, hls_config=config, output_dir=output_dir, backend=backend)
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_allclose(y_qkeras, y_hls4ml.reshape(y_qkeras.shape), atol=0.1)
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Quartus', 'oneAPI'])
+def test_qgru(test_case_id, backend):
+    """
+    Test proper handling of QGRU.
+    """
+    X = np.linspace(-0.5, 0.5, 5)
+    X = np.stack([X, X], axis=1).reshape(1, 5, 2)
+
+    model = Sequential()
+    model.add(Input(shape=(5, 2)))
+    model.add(
+        QGRU(
+            4,
+            kernel_quantizer='quantized_bits(8, 0, alpha=1)',
+            recurrent_quantizer='quantized_bits(8, 0, alpha=1)',
+            bias_quantizer='quantized_bits(8, 0, alpha=1)',
+            state_quantizer='quantized_bits(8, 0, alpha=1)',
+            activation='tanh',
+            recurrent_activation='sigmoid',
+            reset_after='False',
+        )
+    )
+    model.compile()
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', default_precision='ap_fixed<8,1>', backend=backend
+    )
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(model, hls_config=config, output_dir=output_dir, backend=backend)
+    hls_model.compile()
+
+    y_qkeras = model.predict(X)
+    y_hls4ml = hls_model.predict(X)
+
+    np.testing.assert_allclose(y_qkeras, y_hls4ml.reshape(y_qkeras.shape), atol=0.1)
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis'])
+@pytest.mark.parametrize('io_type', ['io_stream'])
+def test_qseparableconv1d(test_case_id, backend, io_type):
+    """
+    Test proper handling of QSeparableConv1D.
+    """
+    x_in = Input((13, 20), name='input_layer')
+    x = QSeparableConv1D(
+        5,
+        3,
+        depthwise_quantizer=quantized_bits(8, 3, alpha=1),
+        pointwise_quantizer=quantized_bits(8, 3, alpha=1),
+        bias_quantizer=quantized_bits(8, 3, alpha=1),
+        name='qsepconv_1',
+    )(x_in)
+    model = Model(inputs=x_in, outputs=x)
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', backend=backend, default_precision='fixed<23,7>'
+    )
+
+    # Use 8 bits for input
+    config['LayerName']['input_layer']['Precision']['result'] = 'fixed<8,1>'
+    # default_precision is will be used for accum_t and result_t of the conv layer, so we don't need to set them here
+    # We need <15,4> for the result of depthwise step
+    config['LayerName']['qsepconv_1']['Precision']['dw_output'] = 'fixed<15,4>'
+
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model,
+        hls_config=config,
+        output_dir=output_dir,
+        io_type=io_type,
+    )
+    hls_model.compile()
+
+    data = np.random.rand(100, 13, 20)
+    input_quantizer = quantized_bits(8, 0, alpha=1)
+    dataq = input_quantizer(data).numpy()
+
+    y_qkeras = model.predict(dataq)
+    y_hls4ml = hls_model.predict(dataq)
+
+    np.testing.assert_allclose(y_qkeras, y_hls4ml.reshape(y_qkeras.shape), rtol=0, atol=0)
+
+
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis'])
+@pytest.mark.parametrize('io_type', ['io_stream'])
+def test_qseparableconv2d(test_case_id, backend, io_type):
+    """
+    Test proper handling of QSeparableConv2D.
+    """
+    x_in = Input((13, 21, 20), name='input_layer')
+    x = QSeparableConv2D(
+        5,
+        3,
+        depthwise_quantizer=quantized_bits(8, 3, alpha=1),
+        pointwise_quantizer=quantized_bits(8, 3, alpha=1),
+        bias_quantizer=quantized_bits(8, 3, alpha=1),
+        name='qsepconv_1',
+    )(x_in)
+    model = Model(inputs=x_in, outputs=x)
+
+    config = hls4ml.utils.config_from_keras_model(
+        model, granularity='name', backend=backend, default_precision='fixed<23,7>'
+    )
+
+    # Use 8 bits for input
+    config['LayerName']['input_layer']['Precision']['result'] = 'fixed<8,1>'
+    # default_precision is will be used for accum_t and result_t of the conv layer, so we don't need to set them here
+    # We need <15,4> for the result of depthwise step
+    config['LayerName']['qsepconv_1']['Precision']['dw_output'] = 'fixed<15,4>'
+
+    output_dir = str(test_root_path / test_case_id)
+    hls_model = hls4ml.converters.convert_from_keras_model(
+        model,
+        hls_config=config,
+        output_dir=output_dir,
+        io_type=io_type,
+    )
+    hls_model.compile()
+
+    data = np.random.rand(100, 13, 21, 20)
+    input_quantizer = quantized_bits(8, 0, alpha=1)
+    dataq = input_quantizer(data).numpy()
+
+    y_qkeras = model.predict(dataq)
+    y_hls4ml = hls_model.predict(dataq)
+
+    np.testing.assert_allclose(y_qkeras, y_hls4ml.reshape(y_qkeras.shape), rtol=0, atol=0)

From 939c0ab35c5256db5a50f502b9ca15efad835ee9 Mon Sep 17 00:00:00 2001
From: Marius Koeppel <koeppel.ma@googlemail.com>
Date: Tue, 19 May 2026 17:40:12 +0200
Subject: [PATCH 10/40] fix util import, remove _base class special case

---
 hls4ml/converters/keras_v3/_base.py             | 2 --
 hls4ml/converters/keras_v3/qkeras/__init__.py   | 2 +-
 hls4ml/converters/keras_v3/qkeras/activation.py | 2 +-
 hls4ml/converters/keras_v3/qkeras/batchnorm.py  | 2 +-
 hls4ml/converters/keras_v3/qkeras/qdense.py     | 2 +-
 5 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/hls4ml/converters/keras_v3/_base.py b/hls4ml/converters/keras_v3/_base.py
index c651149835..ce48bd204e 100644
--- a/hls4ml/converters/keras_v3/_base.py
+++ b/hls4ml/converters/keras_v3/_base.py
@@ -136,8 +136,6 @@ def maybe_get_activation_config(self, layer, out_tensors):
         activation = getattr(layer, 'activation', None)
         name = layer.name
         if activation not in (keras.activations.linear, None):
-            if 'qkeras' in str(type(activation)):
-                return None, None
             assert len(out_tensors) == 1, f'Layer {name} has more than one output, but has an activation function'
             assert isinstance(activation, FunctionType), f'Activation function for layer {name} is not a function'
             intermediate_tensor_name = f'{out_tensors[0].name}_activation'
diff --git a/hls4ml/converters/keras_v3/qkeras/__init__.py b/hls4ml/converters/keras_v3/qkeras/__init__.py
index 5855dd6abe..e81995324d 100644
--- a/hls4ml/converters/keras_v3/qkeras/__init__.py
+++ b/hls4ml/converters/keras_v3/qkeras/__init__.py
@@ -1 +1 @@
-from . import activation, batchnorm, qdense
+from . import activation, batchnorm, qdense, util
diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index 23e1faa5bd..681637ff6e 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -1,7 +1,7 @@
 from typing import Any
 
 from ..core import KerasV3LayerHandler
-from util import IsolatedLayerReader
+from .util import IsolatedLayerReader
 
 
 class QKerasQActivationHandler(KerasV3LayerHandler):
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
index ccd26b1362..96b51905e4 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
-from util import IsolatedLayerReader
+from .util import IsolatedLayerReader
 
 
 class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
index 97a1dfb078..008f402997 100644
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
-from util import IsolatedLayerReader
+from .util import IsolatedLayerReader
 
 
 class QKerasQDenseHandler(KerasV3LayerHandler):

From b17d23a474031d49f46176b54d5cb452cb3e1e23 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 19:03:24 +0200
Subject: [PATCH 11/40] use self.default_config

---
 hls4ml/converters/keras_v3/qkeras/activation.py |  8 ++------
 hls4ml/converters/keras_v3/qkeras/batchnorm.py  | 11 ++---------
 hls4ml/converters/keras_v3/qkeras/qdense.py     | 11 ++---------
 hls4ml/converters/keras_v3/qkeras/util.py       |  7 +++++++
 4 files changed, 13 insertions(+), 24 deletions(-)

diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index 681637ff6e..e5a49b413a 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -1,7 +1,7 @@
 from typing import Any
 
 from ..core import KerasV3LayerHandler
-from .util import IsolatedLayerReader
+from .util import IsolatedLayerReader, set_default_config
 
 
 class QKerasQActivationHandler(KerasV3LayerHandler):
@@ -29,10 +29,6 @@ def handle(
             raise ValueError(f'No v2 handler found for {layer.__class__.__name__}')
 
         hls_conf, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
-
-        hls_conf['input_keras_tensor_names'] = list(input_names)
-        hls_conf['output_keras_tensor_names'] = list(output_names)
-        hls_conf.setdefault('name', layer.name)
-        hls_conf.setdefault('class_name', 'QActivation')
+        hls_conf = set_default_config(hls_conf, self.default_config)
 
         return (hls_conf,)
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
index 96b51905e4..67b8c67ced 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
-from .util import IsolatedLayerReader
+from .util import IsolatedLayerReader, set_default_config
 
 
 class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
@@ -22,14 +22,7 @@ def handle(self, layer, in_tensors, out_tensors):
             raise ValueError(f'No v2 handler found for {layer.__class__.__name__}')
 
         ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
-
-        # override / normalize the names used by the v3 graph parser
-        ret['name'] = layer.name
-        ret['class_name'] = ret.get('class_name', 'QDense')
-        ret['module'] = layer.__module__
-        ret['input_keras_tensor_names'] = [t.name for t in in_tensors]
-        ret['input_shape'] = [list(t.shape[1:]) for t in in_tensors]
-        ret['output_keras_tensor_names'] = [t.name for t in out_tensors]
+        ret = set_default_config(ret, self.default_config)
 
         activation = config.get('activation')
         if activation not in (None, 'linear'):
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
index 008f402997..34574e958e 100644
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
-from .util import IsolatedLayerReader
+from .util import IsolatedLayerReader, set_default_config
 
 
 class QKerasQDenseHandler(KerasV3LayerHandler):
@@ -22,14 +22,7 @@ def handle(self, layer, in_tensors, out_tensors):
             raise ValueError(f'No v2 handler found for {layer.__class__.__name__}')
 
         ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
-
-        # override / normalize the names used by the v3 graph parser
-        ret['name'] = layer.name
-        ret['class_name'] = ret.get('class_name', 'QDense')
-        ret['module'] = layer.__module__
-        ret['input_keras_tensor_names'] = [t.name for t in in_tensors]
-        ret['input_shape'] = [list(t.shape[1:]) for t in in_tensors]
-        ret['output_keras_tensor_names'] = [t.name for t in out_tensors]
+        ret = set_default_config(ret, self.default_config)
 
         activation = config.get('activation')
         if activation not in (None, 'linear'):
diff --git a/hls4ml/converters/keras_v3/qkeras/util.py b/hls4ml/converters/keras_v3/qkeras/util.py
index 95968e1e92..27bc1ad9c0 100644
--- a/hls4ml/converters/keras_v3/qkeras/util.py
+++ b/hls4ml/converters/keras_v3/qkeras/util.py
@@ -11,3 +11,10 @@ def get_weights_data(self, layer_name, var_name):
             if var_name in w.name:
                 return np.array(w)
         return None
+
+
+def set_default_config(hls_conf, default_config):
+    for key, value in default_config.items():
+        if key not in hls_conf.keys():
+            hls_conf[key] = value
+    return hls_conf

From 3953f3400772c79908c4145aa0a7838b87bbad4a Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 19:07:38 +0200
Subject: [PATCH 12/40] rename util -> utils

---
 hls4ml/converters/keras_v3/qkeras/__init__.py           | 2 +-
 hls4ml/converters/keras_v3/qkeras/activation.py         | 2 +-
 hls4ml/converters/keras_v3/qkeras/batchnorm.py          | 2 +-
 hls4ml/converters/keras_v3/qkeras/qdense.py             | 2 +-
 hls4ml/converters/keras_v3/qkeras/{util.py => utils.py} | 0
 5 files changed, 4 insertions(+), 4 deletions(-)
 rename hls4ml/converters/keras_v3/qkeras/{util.py => utils.py} (100%)

diff --git a/hls4ml/converters/keras_v3/qkeras/__init__.py b/hls4ml/converters/keras_v3/qkeras/__init__.py
index e81995324d..50fa6258a5 100644
--- a/hls4ml/converters/keras_v3/qkeras/__init__.py
+++ b/hls4ml/converters/keras_v3/qkeras/__init__.py
@@ -1 +1 @@
-from . import activation, batchnorm, qdense, util
+from . import activation, batchnorm, qdense, utils
diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index e5a49b413a..f3057b4586 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -1,7 +1,7 @@
 from typing import Any
 
 from ..core import KerasV3LayerHandler
-from .util import IsolatedLayerReader, set_default_config
+from .utils import IsolatedLayerReader, set_default_config
 
 
 class QKerasQActivationHandler(KerasV3LayerHandler):
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
index 67b8c67ced..ef01e26f45 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
-from .util import IsolatedLayerReader, set_default_config
+from .utils import IsolatedLayerReader, set_default_config
 
 
 class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
index 34574e958e..a5d39d1847 100644
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -1,7 +1,7 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
-from .util import IsolatedLayerReader, set_default_config
+from .utils import IsolatedLayerReader, set_default_config
 
 
 class QKerasQDenseHandler(KerasV3LayerHandler):
diff --git a/hls4ml/converters/keras_v3/qkeras/util.py b/hls4ml/converters/keras_v3/qkeras/utils.py
similarity index 100%
rename from hls4ml/converters/keras_v3/qkeras/util.py
rename to hls4ml/converters/keras_v3/qkeras/utils.py

From f556feb2c158e59850c6e6d646a75bc189e74519 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 19:15:16 +0200
Subject: [PATCH 13/40] add qkeras-v3 testing

---
 pyproject.toml              | 4 ++++
 test/pytest/ci-template.yml | 6 ++++++
 2 files changed, 10 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index 4860b7809f..fe00f12e9e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -70,6 +70,10 @@ optional-dependencies.testing-keras2 = [
 optional-dependencies.testing-keras3 = [
   "da4ml",
   "hgq2>=0.1.7",
+  "keras>=3.10",
+  "tensorflow>=2.15",
+]
+optional-dependencies.testing-qkeras-v3 = [
   "qkeras-v3",
   "keras>=3.10",
   "tensorflow>=2.15",
diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index ebbcd8a21e..9d8aa6a3fe 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -50,3 +50,9 @@
   variables:
     CONDA_ENV: "hls4ml-testing-keras3"
     EXTRA_DEPS: "[da,testing,testing-keras3,sr]"
+
+.pytest-qkeras-v3-only:
+  extends: .pytest
+  variables:
+    CONDA_ENV: "hls4ml-testing-qkeras-v3"
+    EXTRA_DEPS: "[testing,testing-keras3]"

From 53d600cb841bbda851b2c08c36ba34a43260727c Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 19:23:48 +0200
Subject: [PATCH 14/40] remove not needed matching conditions

---
 hls4ml/converters/keras_v3/qkeras/activation.py | 2 +-
 hls4ml/converters/keras_v3/qkeras/batchnorm.py  | 2 +-
 hls4ml/converters/keras_v3/qkeras/qdense.py     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index f3057b4586..d09e678b59 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -9,7 +9,7 @@ class QKerasQActivationHandler(KerasV3LayerHandler):
 
     def handle(
         self,
-        layer,  # qkeras.qlayers.QActivation
+        layer,
         in_tensors,
         out_tensors,
     ) -> tuple[dict[str, Any], ...]:
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
index ef01e26f45..838a502671 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/batchnorm.py
@@ -5,7 +5,7 @@
 
 
 class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
-    handles = ('qkeras.qlayers.QConv2DBatchnorm', 'QConv2DBatchnorm')
+    handles = ('qkeras.qconv2d_batchnorm.QConv2DBatchnorm')
 
     def handle(self, layer, in_tensors, out_tensors):
         config = layer.get_config()
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
index a5d39d1847..ba5ec7fd40 100644
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ b/hls4ml/converters/keras_v3/qkeras/qdense.py
@@ -5,7 +5,7 @@
 
 
 class QKerasQDenseHandler(KerasV3LayerHandler):
-    handles = ('qkeras.qlayers.QDense', 'QDense')
+    handles = ('qkeras.qlayers.QDense')
 
     def handle(self, layer, in_tensors, out_tensors):
         config = layer.get_config()

From a4e9406c8cfc8f361d4c40feb326a3772d9dee3e Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 19:49:09 +0200
Subject: [PATCH 15/40] move IsolatedLayerReader

---
 hls4ml/converters/keras_v3/qkeras/__init__.py |  2 +-
 .../converters/keras_v3/qkeras/activation.py  |  4 +-
 .../qkeras/{batchnorm.py => layer.py}         |  3 +-
 hls4ml/converters/keras_v3/qkeras/qdense.py   | 43 -------------------
 hls4ml/converters/keras_v3/qkeras/utils.py    | 15 -------
 hls4ml/converters/keras_v3_to_hls.py          | 11 +----
 hls4ml/converters/utils.py                    | 13 ++++++
 7 files changed, 21 insertions(+), 70 deletions(-)
 rename hls4ml/converters/keras_v3/qkeras/{batchnorm.py => layer.py} (94%)
 delete mode 100644 hls4ml/converters/keras_v3/qkeras/qdense.py

diff --git a/hls4ml/converters/keras_v3/qkeras/__init__.py b/hls4ml/converters/keras_v3/qkeras/__init__.py
index 50fa6258a5..bcbb5b40cc 100644
--- a/hls4ml/converters/keras_v3/qkeras/__init__.py
+++ b/hls4ml/converters/keras_v3/qkeras/__init__.py
@@ -1 +1 @@
-from . import activation, batchnorm, qdense, utils
+from . import activation, layer, utils
diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index d09e678b59..128d37e27b 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -1,7 +1,9 @@
 from typing import Any
 
 from ..core import KerasV3LayerHandler
-from .utils import IsolatedLayerReader, set_default_config
+from .utils import set_default_config
+
+from hls4ml.converters.utils import IsolatedLayerReader
 
 
 class QKerasQActivationHandler(KerasV3LayerHandler):
diff --git a/hls4ml/converters/keras_v3/qkeras/batchnorm.py b/hls4ml/converters/keras_v3/qkeras/layer.py
similarity index 94%
rename from hls4ml/converters/keras_v3/qkeras/batchnorm.py
rename to hls4ml/converters/keras_v3/qkeras/layer.py
index 838a502671..c93a7931b5 100644
--- a/hls4ml/converters/keras_v3/qkeras/batchnorm.py
+++ b/hls4ml/converters/keras_v3/qkeras/layer.py
@@ -1,8 +1,9 @@
 import numpy as np
 
 from ..core import KerasV3LayerHandler
-from .utils import IsolatedLayerReader, set_default_config
+from .utils import set_default_config
 
+from hls4ml.converters.utils import IsolatedLayerReader
 
 class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
     handles = ('qkeras.qconv2d_batchnorm.QConv2DBatchnorm')
diff --git a/hls4ml/converters/keras_v3/qkeras/qdense.py b/hls4ml/converters/keras_v3/qkeras/qdense.py
deleted file mode 100644
index ba5ec7fd40..0000000000
--- a/hls4ml/converters/keras_v3/qkeras/qdense.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import numpy as np
-
-from ..core import KerasV3LayerHandler
-from .utils import IsolatedLayerReader, set_default_config
-
-
-class QKerasQDenseHandler(KerasV3LayerHandler):
-    handles = ('qkeras.qlayers.QDense')
-
-    def handle(self, layer, in_tensors, out_tensors):
-        config = layer.get_config()
-        layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
-
-        reader = IsolatedLayerReader(layer)
-        input_shapes = [list(t.shape) for t in in_tensors]
-        input_names = [t.name for t in in_tensors]
-
-        from hls4ml.converters.keras_v2_to_hls import layer_handlers as v2_layer_handlers
-
-        v2_handler = v2_layer_handlers.get(layer.__class__.__name__)
-        if v2_handler is None:
-            raise ValueError(f'No v2 handler found for {layer.__class__.__name__}')
-
-        ret, _ = v2_handler(layer_dict, input_names, input_shapes, reader)
-        ret = set_default_config(ret, self.default_config)
-
-        activation = config.get('activation')
-        if activation not in (None, 'linear'):
-            from hls4ml.converters.keras.qkeras import get_activation_quantizer
-
-            activation_config = get_activation_quantizer(layer_dict, input_names)
-            intermediate_tensor_name = f'{out_tensors[0].name}_activation'
-            ret['output_keras_tensor_names'] = [intermediate_tensor_name]
-            activation_config.update(
-                {
-                    'name': f'{layer.name}_activation',
-                    'input_keras_tensor_names': [intermediate_tensor_name],
-                    'output_keras_tensor_names': [out_tensors[0].name],
-                }
-            )
-            return ret, activation_config
-
-        return ret
diff --git a/hls4ml/converters/keras_v3/qkeras/utils.py b/hls4ml/converters/keras_v3/qkeras/utils.py
index 27bc1ad9c0..e9d6fef8e8 100644
--- a/hls4ml/converters/keras_v3/qkeras/utils.py
+++ b/hls4ml/converters/keras_v3/qkeras/utils.py
@@ -1,18 +1,3 @@
-import numpy as np
-
-
-class IsolatedLayerReader:
-    def __init__(self, layer):
-        self.layer = layer
-
-    def get_weights_data(self, layer_name, var_name):
-        assert layer_name == self.layer.name, f'Processing {self.layer.name}, but handler tried to read {layer_name}'
-        for w in self.layer.weights:
-            if var_name in w.name:
-                return np.array(w)
-        return None
-
-
 def set_default_config(hls_conf, default_config):
     for key, value in default_config.items():
         if key not in hls_conf.keys():
diff --git a/hls4ml/converters/keras_v3_to_hls.py b/hls4ml/converters/keras_v3_to_hls.py
index 57c83f249b..ae3aed3663 100644
--- a/hls4ml/converters/keras_v3_to_hls.py
+++ b/hls4ml/converters/keras_v3_to_hls.py
@@ -7,6 +7,7 @@
 import numpy as np
 
 from hls4ml.model import ModelGraph
+from hls4ml.converters.utils import IsolatedLayerReader
 
 if typing.TYPE_CHECKING:
     import keras
@@ -238,15 +239,7 @@ def v2_call(
         config = layer.get_config()
         layer_dict = {'config': config, 'class_name': layer.__class__.__name__}
 
-        class IsolatedLayerReader:
-            def get_weights_data(self, layer_name, var_name):
-                assert layer_name == layer.name, f'Processing {layer.name}, but handler tried to read {layer_name}'
-                for w in layer.weights:
-                    if var_name in w.name:
-                        return np.array(w)
-                return None
-
-        reader = IsolatedLayerReader()
+        reader = IsolatedLayerReader(layer)
         input_shapes = [list(t.shape) for t in inp_tensors]
         input_names = [t.name for t in inp_tensors]
         output_names = [t.name for t in out_tensors]
diff --git a/hls4ml/converters/utils.py b/hls4ml/converters/utils.py
index d35ec11fff..95928df2c4 100644
--- a/hls4ml/converters/utils.py
+++ b/hls4ml/converters/utils.py
@@ -1,4 +1,5 @@
 import math
+import numpy as np
 
 
 def parse_data_format(input_shape, data_format='channels_last'):
@@ -287,3 +288,15 @@ def compute_padding_2d_pytorch(
             pad_left = pad_width
 
     return (out_height, out_width, pad_top, pad_bottom, pad_left, pad_right)
+
+
+class IsolatedLayerReader:
+    def __init__(self, layer):
+        self.layer = layer
+
+    def get_weights_data(self, layer_name, var_name):
+        assert layer_name == self.layer.name, f'Processing {self.layer.name}, but handler tried to read {layer_name}'
+        for w in self.layer.weights:
+            if var_name in w.name:
+                return np.array(w)
+        return None

From a477078d2678b88ce52786506fff435d206beae4 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 19:50:30 +0200
Subject: [PATCH 16/40] create QKerasV3LayerHandler to handle all qkeras layers

---
 hls4ml/converters/keras_v3/qkeras/layer.py | 11 ++++++--
 hls4ml/converters/keras_v3_to_hls.py       | 30 +++++++---------------
 2 files changed, 18 insertions(+), 23 deletions(-)

diff --git a/hls4ml/converters/keras_v3/qkeras/layer.py b/hls4ml/converters/keras_v3/qkeras/layer.py
index c93a7931b5..e06ef1a89e 100644
--- a/hls4ml/converters/keras_v3/qkeras/layer.py
+++ b/hls4ml/converters/keras_v3/qkeras/layer.py
@@ -5,8 +5,15 @@
 
 from hls4ml.converters.utils import IsolatedLayerReader
 
-class QKerasQConv2DBatchnormHandler(KerasV3LayerHandler):
-    handles = ('qkeras.qconv2d_batchnorm.QConv2DBatchnorm')
+
+class QKerasV3LayerHandler(KerasV3LayerHandler):
+    handles = (
+        'qkeras.qlayers.QDense',
+        'qkeras.qconvolutional.QConv1D',
+        'qkeras.qconvolutional.QConv2D',
+        'qkeras.qconvolutional.QDepthwiseConv2D',
+        'qkeras.qconv2d_batchnorm.QConv2DBatchnorm'
+    )
 
     def handle(self, layer, in_tensors, out_tensors):
         config = layer.get_config()
diff --git a/hls4ml/converters/keras_v3_to_hls.py b/hls4ml/converters/keras_v3_to_hls.py
index ae3aed3663..10205be1c7 100644
--- a/hls4ml/converters/keras_v3_to_hls.py
+++ b/hls4ml/converters/keras_v3_to_hls.py
@@ -255,29 +255,17 @@ def v2_call(
 
         activation = getattr(layer, 'activation', None)
         if activation not in (keras.activations.linear, None):
+            assert isinstance(activation, FunctionType), f'Activation function for layer {layer.name} is not a function'
             intermediate_tensor_name = f'{output_names[0]}_activation'
             ret[0]['output_keras_tensor_names'] = (intermediate_tensor_name,)
-            if 'qkeras' in str(type(activation)):
-                from hls4ml.converters.keras.qkeras import get_activation_quantizer
-
-                act_config = get_activation_quantizer(layer_dict, input_names)
-                act_config.update(
-                    {
-                        'name': f'{layer.name}_activation',
-                        'input_keras_tensor_names': (intermediate_tensor_name,),
-                        'output_keras_tensor_names': output_names,
-                    }
-                )
-            else:
-                assert isinstance(activation, FunctionType), f'Activation function for layer {layer.name} is not a function'
-                act_cls_name = activation.__name__
-                act_config = {
-                    'class_name': 'Activation',
-                    'activation': act_cls_name,
-                    'name': f'{layer.name}_{act_cls_name}',
-                    'input_keras_tensor_names': (intermediate_tensor_name,),
-                    'output_keras_tensor_names': output_names,
-                }
+            act_cls_name = activation.__name__
+            act_config = {
+                'class_name': 'Activation',
+                'activation': act_cls_name,
+                'name': f'{layer.name}_{act_cls_name}',
+                'input_keras_tensor_names': (intermediate_tensor_name,),
+                'output_keras_tensor_names': output_names,
+            }
             ret = *ret, act_config
         return ret
 

From a1d168863494509867c4bad599e61d7a73b3cc8a Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 20:00:28 +0200
Subject: [PATCH 17/40] add back built check

---
 hls4ml/converters/keras_v3_to_hls.py | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

diff --git a/hls4ml/converters/keras_v3_to_hls.py b/hls4ml/converters/keras_v3_to_hls.py
index 10205be1c7..6d393b8e16 100644
--- a/hls4ml/converters/keras_v3_to_hls.py
+++ b/hls4ml/converters/keras_v3_to_hls.py
@@ -270,13 +270,6 @@ def v2_call(
         return ret
 
 
-def _model_has_io_graph(model: 'keras.Model') -> bool:
-    try:
-        return bool(model.inputs) and bool(model.outputs)
-    except (AttributeError, ValueError):
-        return False
-
-
 def parse_keras_v3_model(model: 'keras.Model', allow_da_fallback=True, allow_v2_fallback=True):
     """Parse a keras model into a list of dictionaries, each
     representing a layer in the HLS model, and a list of input and
@@ -303,17 +296,13 @@ def parse_keras_v3_model(model: 'keras.Model', allow_da_fallback=True, allow_v2_
         ValueError: If a circular dependency is detected.
     """
 
+    assert model.built, 'Model must be built before parsing'
+
     import keras
 
-    if isinstance(model, keras.Sequential) and getattr(model, '_functional', None) is not None:
+    if isinstance(model, keras.Sequential):
         model = model._functional  # everything is functional under the hood lol
 
-    if not getattr(model, 'built', False) and not _model_has_io_graph(model):
-        raise ValueError(
-            'Model must be built or called before parsing. '
-            'For Sequential models, add an Input layer or call model.build(input_shape) first.'
-        )
-
     from .keras_v2_to_hls import layer_handlers as v2_layer_handlers  # Delayed import to avoid circular import
 
     keras_v3_dispatcher = KerasV3HandlerDispatcher(

From c843e3898a28240d6a356673e85318541b5f18ba Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 20:03:00 +0200
Subject: [PATCH 18/40] revert test_keras_v3_api.py

---
 test/pytest/test_keras_v3_api.py | 88 --------------------------------
 1 file changed, 88 deletions(-)

diff --git a/test/pytest/test_keras_v3_api.py b/test/pytest/test_keras_v3_api.py
index 6c118065a0..21f90d5d60 100644
--- a/test/pytest/test_keras_v3_api.py
+++ b/test/pytest/test_keras_v3_api.py
@@ -1,6 +1,4 @@
 import math
-import sys
-import types
 from pathlib import Path
 
 import keras
@@ -31,92 +29,6 @@
 test_root_path = Path(__file__).parent
 
 
-def test_qkeras_qdense_v3_handler_chains_quantized_activation(monkeypatch):
-    from hls4ml.converters.keras_v2_to_hls import layer_handlers
-    from hls4ml.converters.keras_v3.qkeras.qdense import QKerasQDenseHandler
-
-    qkeras_module = types.ModuleType('qkeras')
-    quantizers_module = types.ModuleType('qkeras.quantizers')
-
-    class quantized_relu:
-        def get_config(self):
-            return {'bits': 8, 'integer': 0, 'negative_slope': 0}
-
-    quantizers_module.get_quantizer = lambda config: quantized_relu()
-    monkeypatch.setitem(sys.modules, 'qkeras', qkeras_module)
-    monkeypatch.setitem(sys.modules, 'qkeras.quantizers', quantizers_module)
-
-    def fake_qdense_handler(layer_dict, input_names, input_shapes, reader):
-        return {'name': layer_dict['config']['name'], 'class_name': 'Dense'}, input_shapes[0]
-
-    monkeypatch.setitem(layer_handlers, 'QDense', fake_qdense_handler)
-
-    class Tensor:
-        def __init__(self, name):
-            self.name = name
-            self.shape = (None, 10)
-
-    QDense = type(
-        'QDense',
-        (),
-        {
-            'name': 'qdense',
-            'weights': [],
-            '__module__': 'qkeras.qlayers',
-            'get_config': lambda self: {'name': 'qdense', 'activation': 'quantized_relu(8, 0)'},
-        },
-    )
-
-    dense_config, activation_config = QKerasQDenseHandler().handle(QDense(), [Tensor('input')], [Tensor('output')])
-
-    assert dense_config['output_keras_tensor_names'] == ['output_activation']
-    assert activation_config['input_keras_tensor_names'] == ['output_activation']
-    assert activation_config['output_keras_tensor_names'] == ['output']
-    assert activation_config['activation'] == 'relu'
-    assert activation_config['activation_quantizer']['class_name'] == 'quantized_relu'
-
-
-def test_qkeras_activation_dict_ternary_maps_to_ternary_tanh(monkeypatch):
-    qkeras_module = types.ModuleType('qkeras')
-    quantizers_module = types.ModuleType('qkeras.quantizers')
-    quantizers_module.get_quantizer = lambda config: None
-    monkeypatch.setitem(sys.modules, 'qkeras', qkeras_module)
-    monkeypatch.setitem(sys.modules, 'qkeras.quantizers', quantizers_module)
-
-    from hls4ml.converters.keras.qkeras import get_activation_quantizer
-
-    layer = {
-        'class_name': 'QDense',
-        'config': {
-            'name': 'qdense',
-            'activation': {
-                'module': 'qkeras.quantizers',
-                'class_name': 'ternary',
-                'config': {'alpha': None, 'threshold': None},
-                'registered_name': 'qkeras>ternary',
-            },
-        },
-    }
-
-    activation_config = get_activation_quantizer(layer, ['input'])
-
-    assert activation_config['class_name'] == 'TernaryTanh'
-    assert activation_config['activation'] == 'ternary_tanh'
-    assert activation_config['threshold'] == 0.33
-    assert activation_config['activation_quantizer']['class_name'] == 'ternary_tanh'
-
-
-def test_config_from_functional_model_with_false_built_flag():
-    inputs = keras.Input(shape=(3,), name='input')
-    outputs = Dense(2, name='dense')(inputs)
-    model = keras.Model(inputs, outputs)
-    model.built = False
-
-    config = hls4ml.utils.config_from_keras_model(model, granularity='name')
-
-    assert 'dense' in config['LayerName']
-
-
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus', 'oneAPI', 'Catapult'])
 @pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
 def test_dense(test_case_id, backend, io_type):

From 5e0196cd566c9d4de79b0c06f6be9aec75679734 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 20:16:47 +0200
Subject: [PATCH 19/40] use math.prod

---
 hls4ml/model/types.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/hls4ml/model/types.py b/hls4ml/model/types.py
index 99a658b5d1..aa69130d9b 100644
--- a/hls4ml/model/types.py
+++ b/hls4ml/model/types.py
@@ -5,6 +5,7 @@
 higher-dimensional tensors, which are defined as arrays or FIFO streams in the generated code.
 """
 
+import math
 from enum import Enum
 
 import numpy as np
@@ -837,10 +838,7 @@ def _format(self):
 
     def __iter__(self):
         data = self._format()
-        if hasattr(np, 'product'):
-            self._iterator = iter(data.reshape((np.product(data.shape[:-1]), 2)))
-        else:
-            self._iterator = iter(data.reshape((np.prod(data.shape[:-1]), 2)))
+        self._iterator = iter(data.reshape((math.prod(data.shape[:-1]), 2)))
         return self
 
     def __next__(self):

From e6676d71b600b52dc4df043f357dd161bb56d42e Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 20:20:13 +0200
Subject: [PATCH 20/40] revert quantizers

---
 hls4ml/model/quantizers.py | 29 ++---------------------------
 1 file changed, 2 insertions(+), 27 deletions(-)

diff --git a/hls4ml/model/quantizers.py b/hls4ml/model/quantizers.py
index 4e3f7401f7..fbcdb00051 100644
--- a/hls4ml/model/quantizers.py
+++ b/hls4ml/model/quantizers.py
@@ -106,10 +106,7 @@ def __init__(self, config):
         from qkeras.quantizers import get_quantizer
 
         self.qkeras_config = config
-        try:
-            self.quantizer_fn = get_quantizer(config)
-        except Exception:
-            self.quantizer_fn = None
+        self.quantizer_fn = get_quantizer(config)
         self.alpha = config['config'].get('alpha', None)
         if config['class_name'] == 'quantized_bits':
             self.bits = config['config']['bits']
@@ -129,29 +126,7 @@ def __init__(self, config):
 
     def __call__(self, data):
         data = np.array(data, dtype='float32')
-        if self.quantizer_fn is not None:
-            try:
-                return self.quantizer_fn(data).numpy()
-            except TypeError:
-                pass
-        if self.qkeras_config['class_name'] != 'quantized_bits':
-            raise RuntimeError(f'Cannot evaluate QKeras quantizer {self.qkeras_config["class_name"]}')
-        return self._quantize_bits(data, self.qkeras_config)
-
-    def _quantize_bits(self, data, quantizer_config):
-        config = quantizer_config['config']
-        bits = config['bits']
-        integer = config.get('integer', 0)
-        keep_negative = config.get('keep_negative', True)
-        alpha = config.get('alpha', 1)
-        if alpha is None:
-            alpha = 1
-        fractional = bits - integer - (1 if keep_negative else 0)
-        scale = 2.0**fractional
-        quantized = np.round(data / alpha * scale) / scale * alpha
-        lower = -(2.0**integer) * alpha if keep_negative else 0.0
-        upper = (2.0**integer - 1.0 / scale) * alpha
-        return np.clip(quantized, lower, upper)
+        return self.quantizer_fn(data).numpy()
 
     def _get_type(self, quantizer_config):
         width = quantizer_config['config']['bits']

From 5fe8b05709a3f7b2d943a682c7f74b2112ac8c83 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 20:57:27 +0200
Subject: [PATCH 21/40] revert passes/qkeras.py

---
 hls4ml/model/optimizer/passes/qkeras.py | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/hls4ml/model/optimizer/passes/qkeras.py b/hls4ml/model/optimizer/passes/qkeras.py
index 127f24fca1..de4052198e 100644
--- a/hls4ml/model/optimizer/passes/qkeras.py
+++ b/hls4ml/model/optimizer/passes/qkeras.py
@@ -112,18 +112,15 @@ def match(self, node):
     def transform(self, model, node):
         # The quantizer has to be applied to set the scale attribute
         # This must be applied to the _unquantized_ weights to obtain the correct scale
+        import tensorflow as tf
 
         quantizer = node.weights['weight'].quantizer.quantizer_fn  # get QKeras quantizer
         weights = node.weights['weight'].data_unquantized  # get weights
-        qweights = quantizer(weights)
-        if hasattr(qweights, 'numpy'):
-            qweights = qweights.numpy()
+        qweights = quantizer(tf.convert_to_tensor(weights))
         if isinstance(quantizer.scale, (int, float)):
             scale = np.ones(shape=node.get_output_variable().shape[-1]) * quantizer.scale
-        elif hasattr(quantizer.scale, 'numpy'):
-            scale = quantizer.scale.numpy()
         else:
-            scale = quantizer.scale
+            scale = quantizer.scale.numpy()
         unscale = 1.0 / scale
 
         new_weights = unscale * qweights  # use the quantized weights for safety
@@ -136,7 +133,7 @@ def transform(self, model, node):
 
         # update the weights also applying the hls4ml quantizer
         # this is only needed for the binary layers which encode -1 as 0
-        quantized_new_weights = node.weights['weight'].quantizer(new_weights)
+        quantized_new_weights = node.weights['weight'].quantizer(new_weights.numpy())
         node.weights['weight'].data = quantized_new_weights
 
         # Move the biases from the Dense layer to the ApplyAlpha layer

From 2cd5e30697d9f1aa7d88b4d6809a7076a47965fb Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 21:00:31 +0200
Subject: [PATCH 22/40] revert converters/keras/qkeras.py

---
 hls4ml/converters/keras/qkeras.py | 57 +++++++++++--------------------
 1 file changed, 20 insertions(+), 37 deletions(-)

diff --git a/hls4ml/converters/keras/qkeras.py b/hls4ml/converters/keras/qkeras.py
index 30235d9fff..01a92c3d5b 100644
--- a/hls4ml/converters/keras/qkeras.py
+++ b/hls4ml/converters/keras/qkeras.py
@@ -8,8 +8,6 @@
 
 def get_quantizer_from_config(keras_layer, quantizer_var):
     quantizer_config = keras_layer['config'].get(f'{quantizer_var}_quantizer', None)
-    if quantizer_config is None:
-        quantizer_config = keras_layer['config'].get(f'{quantizer_var[0]}q_conf', None)
     if quantizer_config is None:
         return None  # No quantizer specified in the layer
     if keras_layer['class_name'] == 'QBatchNormalization':
@@ -120,42 +118,27 @@ def get_activation_quantizer(keras_layer, input_names, activation_name='activati
     layer = parse_default_keras_layer(keras_layer, input_names)
 
     activation_config = keras_layer['config'][activation_name]
-    if isinstance(activation_config, dict):
-        activation_config = {
-            'class_name': activation_config['class_name'],
-            'config': activation_config.get('config', {}),
-        }
-        if activation_config['class_name'] == 'ternary':
-            activation_config['class_name'] = 'ternary_tanh'
-        elif activation_config['class_name'] == 'binary':
-            activation_config['class_name'] = 'binary_tanh'
-        elif activation_config['class_name'] == 'quantized_bits' and not activation_config['config'].get(
-            'keep_negative', True
-        ):
-            activation_config['class_name'] = 'quantized_relu'
-            activation_config['config'].setdefault('negative_slope', 0.0)
+    quantizer_obj = get_quantizer(activation_config)
+    activation_config = {}
+    # some activations are classes
+    if hasattr(quantizer_obj, 'get_config'):
+        activation_config['class_name'] = quantizer_obj.__class__.__name__
+        if activation_config['class_name'] == 'ternary' or activation_config['class_name'] == 'binary':
+            activation_config['class_name'] += '_tanh'
+        activation_config['config'] = quantizer_obj.get_config()
+    # some activation quantizers are just functions with no config
     else:
-        quantizer_obj = get_quantizer(activation_config)
-        activation_config = {}
-        # some activations are classes
-        if hasattr(quantizer_obj, 'get_config'):
-            activation_config['class_name'] = quantizer_obj.__class__.__name__
-            if activation_config['class_name'] == 'ternary' or activation_config['class_name'] == 'binary':
-                activation_config['class_name'] += '_tanh'
-            activation_config['config'] = quantizer_obj.get_config()
-        # some activation quantizers are just functions with no config
+        activation_config['config'] = {}
+        if 'binary' in quantizer_obj.__name__:
+            activation_config['class_name'] = 'binary_tanh'
+            activation_config['config']['bits'] = 1
+            activation_config['config']['integer'] = 1
+        elif 'ternary' in quantizer_obj.__name__:
+            activation_config['class_name'] = 'ternary_tanh'
+            activation_config['config']['bits'] = 2
+            activation_config['config']['integer'] = 2
         else:
-            activation_config['config'] = {}
-            if 'binary' in quantizer_obj.__name__:
-                activation_config['class_name'] = 'binary_tanh'
-                activation_config['config']['bits'] = 1
-                activation_config['config']['integer'] = 1
-            elif 'ternary' in quantizer_obj.__name__:
-                activation_config['class_name'] = 'ternary_tanh'
-                activation_config['config']['bits'] = 2
-                activation_config['config']['integer'] = 2
-            else:
-                activation_config['class_name'] = 'unknown'
+            activation_config['class_name'] = 'unknown'
 
     if activation_config['class_name'] not in supported_activations:
         raise Exception('Unsupported QKeras activation: {}'.format(activation_config['class_name']))
@@ -182,7 +165,7 @@ def get_activation_quantizer(keras_layer, input_names, activation_name='activati
         layer['slope_prec'] = FixedPrecisionType(width=2, integer=0, signed=False)
         layer['shift_prec'] = FixedPrecisionType(width=2, integer=0, signed=False)
         layer[activation_name] = activation_config['class_name'].replace('quantized_', 'hard_')
-    elif activation_config['class_name'] == 'quantized_relu' and activation_config['config'].get('negative_slope', 0) != 0:
+    elif activation_config['class_name'] == 'quantized_relu' and activation_config['config']['negative_slope'] != 0:
         layer['class_name'] = 'LeakyReLU'
         layer[activation_name] = activation_config['class_name'].replace('quantized_', 'leaky_')
         layer['activ_param'] = activation_config['config']['negative_slope']

From 9665a0e88c5a6fffa0a98e2869254d4691939b99 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Tue, 19 May 2026 21:01:42 +0200
Subject: [PATCH 23/40] pre-commit changes

---
 hls4ml/converters/keras_v3/qkeras/activation.py | 5 ++---
 hls4ml/converters/keras_v3/qkeras/layer.py      | 6 ++----
 hls4ml/converters/keras_v3_to_hls.py            | 4 +---
 hls4ml/converters/utils.py                      | 1 +
 pyproject.toml                                  | 4 ++--
 5 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/hls4ml/converters/keras_v3/qkeras/activation.py b/hls4ml/converters/keras_v3/qkeras/activation.py
index 128d37e27b..281da5cb30 100644
--- a/hls4ml/converters/keras_v3/qkeras/activation.py
+++ b/hls4ml/converters/keras_v3/qkeras/activation.py
@@ -1,10 +1,10 @@
 from typing import Any
 
+from hls4ml.converters.utils import IsolatedLayerReader
+
 from ..core import KerasV3LayerHandler
 from .utils import set_default_config
 
-from hls4ml.converters.utils import IsolatedLayerReader
-
 
 class QKerasQActivationHandler(KerasV3LayerHandler):
     handles = ('qkeras.qlayers.QActivation', 'QActivation')
@@ -22,7 +22,6 @@ def handle(
         reader = IsolatedLayerReader(layer)
         input_shapes = [list(t.shape) for t in in_tensors]
         input_names = [t.name for t in in_tensors]
-        output_names = [t.name for t in out_tensors]
 
         from hls4ml.converters.keras_v2_to_hls import layer_handlers as v2_layer_handlers
 
diff --git a/hls4ml/converters/keras_v3/qkeras/layer.py b/hls4ml/converters/keras_v3/qkeras/layer.py
index e06ef1a89e..eb1cf5ccd9 100644
--- a/hls4ml/converters/keras_v3/qkeras/layer.py
+++ b/hls4ml/converters/keras_v3/qkeras/layer.py
@@ -1,10 +1,8 @@
-import numpy as np
+from hls4ml.converters.utils import IsolatedLayerReader
 
 from ..core import KerasV3LayerHandler
 from .utils import set_default_config
 
-from hls4ml.converters.utils import IsolatedLayerReader
-
 
 class QKerasV3LayerHandler(KerasV3LayerHandler):
     handles = (
@@ -12,7 +10,7 @@ class QKerasV3LayerHandler(KerasV3LayerHandler):
         'qkeras.qconvolutional.QConv1D',
         'qkeras.qconvolutional.QConv2D',
         'qkeras.qconvolutional.QDepthwiseConv2D',
-        'qkeras.qconv2d_batchnorm.QConv2DBatchnorm'
+        'qkeras.qconv2d_batchnorm.QConv2DBatchnorm',
     )
 
     def handle(self, layer, in_tensors, out_tensors):
diff --git a/hls4ml/converters/keras_v3_to_hls.py b/hls4ml/converters/keras_v3_to_hls.py
index 6d393b8e16..9abd031b56 100644
--- a/hls4ml/converters/keras_v3_to_hls.py
+++ b/hls4ml/converters/keras_v3_to_hls.py
@@ -4,10 +4,8 @@
 from types import FunctionType
 from typing import Any
 
-import numpy as np
-
-from hls4ml.model import ModelGraph
 from hls4ml.converters.utils import IsolatedLayerReader
+from hls4ml.model import ModelGraph
 
 if typing.TYPE_CHECKING:
     import keras
diff --git a/hls4ml/converters/utils.py b/hls4ml/converters/utils.py
index 95928df2c4..e4ddda2c50 100644
--- a/hls4ml/converters/utils.py
+++ b/hls4ml/converters/utils.py
@@ -1,4 +1,5 @@
 import math
+
 import numpy as np
 
 
diff --git a/pyproject.toml b/pyproject.toml
index fe00f12e9e..bb1c850036 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -49,7 +49,7 @@ optional-dependencies.qkeras = [
   "tensorflow>=2.8,<=2.14.1",
   "tensorflow-model-optimization<=0.7.5",
 ]
-optional-dependencies.qkeras-v3 = ["qkeras-v3"]
+optional-dependencies.qkeras-v3 = [ "qkeras-v3" ]
 optional-dependencies.quartus-report = [ "calmjs-parse", "tabulate" ]
 optional-dependencies.sr = [ "sympy>=1.13.1" ]
 optional-dependencies.testing = [
@@ -74,8 +74,8 @@ optional-dependencies.testing-keras3 = [
   "tensorflow>=2.15",
 ]
 optional-dependencies.testing-qkeras-v3 = [
-  "qkeras-v3",
   "keras>=3.10",
+  "qkeras-v3",
   "tensorflow>=2.15",
 ]
 urls.Homepage = "https://fastmachinelearning.org/hls4ml"

From 2a20082ff016c9372d575d1f8af7b84616fcf270 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Wed, 20 May 2026 15:25:36 +0200
Subject: [PATCH 24/40] update submodule, remove signed check

---
 example-models             | 2 +-
 hls4ml/model/quantizers.py | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/example-models b/example-models
index e7a9dee394..ce390f9a80 160000
--- a/example-models
+++ b/example-models
@@ -1 +1 @@
-Subproject commit e7a9dee394b6c1f6e0eb23178d34e55f077297fe
+Subproject commit ce390f9a806dac2c254736c6113896c540e7447b
diff --git a/hls4ml/model/quantizers.py b/hls4ml/model/quantizers.py
index fbcdb00051..d306a4da75 100644
--- a/hls4ml/model/quantizers.py
+++ b/hls4ml/model/quantizers.py
@@ -139,8 +139,7 @@ def _get_type(self, quantizer_config):
             else:
                 return IntegerPrecisionType(width=width, signed=True)
         else:
-            signed = quantizer_config['config'].get('keep_negative', True)
-            return FixedPrecisionType(width=width, integer=integer + int(signed), signed=signed)
+            return FixedPrecisionType(width=width, integer=integer + 1, signed=True)
 
     def serialize_state(self):
         state = {

From 26a12a79a05bbf175df82dab91f8c8e7d2266ef8 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Wed, 20 May 2026 15:46:47 +0200
Subject: [PATCH 25/40] add back backend

---
 test/pytest/test_qkerasV3.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
index 054517b5e8..ebad3ecf2d 100644
--- a/test/pytest/test_qkerasV3.py
+++ b/test/pytest/test_qkerasV3.py
@@ -495,7 +495,7 @@ def test_qconv_activation_kwarg(test_case_id, qconv_layer, input_shape, input_da
     model.compile()
 
     config = hls4ml.utils.config_from_keras_model(
-        model, granularity='name', default_precision='fixed<24,8>', backend='Vivado'
+        model, granularity='name', default_precision='fixed<24,8>', backend=backend
     )
     assert 'qconv_activation' in config['LayerName']
 

From 862ac93350e1f9b3af24c55565604224f41eda77 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Wed, 20 May 2026 22:34:54 +0200
Subject: [PATCH 26/40] add qkeras-v3 testcase

---
 test/pytest/ci-template.yml     |  2 +-
 test/pytest/generate_ci_yaml.py | 18 +++++++++++++++++-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index 9d8aa6a3fe..481466d556 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -55,4 +55,4 @@
   extends: .pytest
   variables:
     CONDA_ENV: "hls4ml-testing-qkeras-v3"
-    EXTRA_DEPS: "[testing,testing-keras3]"
+    EXTRA_DEPS: "[testing,testing-keras3,qkeras-v3]"
diff --git a/test/pytest/generate_ci_yaml.py b/test/pytest/generate_ci_yaml.py
index 684abc0511..a48bed9e7e 100644
--- a/test/pytest/generate_ci_yaml.py
+++ b/test/pytest/generate_ci_yaml.py
@@ -36,6 +36,7 @@
     'test_multiout_onnx',
     'test_keras_v3_profiling',
 }
+QKERAS3_LIST = {'test_qkerasV3'}
 
 # Test files to split by individual test cases
 # Value = chunk size per CI job
@@ -79,7 +80,7 @@ def generate_test_yaml(test_root='.'):
     test_paths = [
         path
         for path in test_root.glob('**/test_*.py')
-        if path.stem not in (BLACKLIST | LONGLIST | set(SPLIT_BY_TEST_CASE.keys()) | KERAS3_LIST)
+        if path.stem not in (BLACKLIST | LONGLIST | set(SPLIT_BY_TEST_CASE.keys()) | KERAS3_LIST | QKERAS3_LIST)
     ]
     need_example_models = [uses_example_model(path) for path in test_paths]
 
@@ -140,6 +141,21 @@ def generate_test_yaml(test_root='.'):
         diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
         yml.update(diff_yml)
 
+    qkeras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in QKERAS3_LIST]
+    qkeras3_need_examples = [uses_example_model(path) for path in qkeras3_paths]
+
+    qk3_idxs = list(range(len(qkeras3_need_examples)))
+    qk3_idxs = sorted(qk3_idxs, key=lambda i: f'{qkeras3_need_examples[i]}_{path_to_name(qkeras3_paths[i])}')
+
+    for batch_idxs in batched(qk3_idxs, n_test_files_per_yml):
+        batch_paths: list[Path] = [qkeras3_paths[i] for i in batch_idxs]
+        names = [path_to_name(path) for path in batch_paths]
+        name = 'qkerasV3'
+        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+        batch_need_example_model = int(any([qkeras3_need_examples[i] for i in batch_idxs]))
+        diff_yml = yaml.safe_load(template.format(name, '.pytest-qkeras-v3-only', test_files, batch_need_example_model))
+        yml.update(diff_yml)
+
     return yml
 
 

From eeaf804194ba537b3add168f8071e2f2c45d10fa Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Wed, 20 May 2026 23:06:26 +0200
Subject: [PATCH 27/40] test only qkerasV3

---
 test/pytest/ci-template.yml     |   2 +-
 test/pytest/generate_ci_yaml.py | 107 ++++++++++++++++----------------
 2 files changed, 55 insertions(+), 54 deletions(-)

diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index 481466d556..3d1a8912c2 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -54,5 +54,5 @@
 .pytest-qkeras-v3-only:
   extends: .pytest
   variables:
-    CONDA_ENV: "hls4ml-testing-qkeras-v3"
+    CONDA_ENV: "hls4ml-testing-keras3"
     EXTRA_DEPS: "[testing,testing-keras3,qkeras-v3]"
diff --git a/test/pytest/generate_ci_yaml.py b/test/pytest/generate_ci_yaml.py
index a48bed9e7e..f0d3d51464 100644
--- a/test/pytest/generate_ci_yaml.py
+++ b/test/pytest/generate_ci_yaml.py
@@ -88,58 +88,58 @@ def generate_test_yaml(test_root='.'):
     idxs = sorted(idxs, key=lambda i: f'{need_example_models[i]}_{path_to_name(test_paths[i])}')
 
     yml = None
-    for batch_idxs in batched(idxs, n_test_files_per_yml):
-        batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
-        names = [path_to_name(path) for path in batch_paths]
-        name = '+'.join(names)
-        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-        batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
-        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
-        if yml is None:
-            yml = diff_yml
-        else:
-            yml.update(diff_yml)
-
-    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
-    for path in test_paths:
-        name = path.stem.replace('test_', '')
-        test_file = str(path.relative_to(test_root))
-        needs_examples = uses_example_model(path)
-        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
-        yml.update(diff_yml)
-
-    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
-    for path in test_paths:
-        stem = path.stem
-        name_base = stem.replace('test_', '')
-        test_file = str(path.relative_to(test_root))
-        test_ids = collect_test_functions_from_ast(test_file)
-        chunk_size = SPLIT_BY_TEST_CASE[stem]
-        needs_examples = uses_example_model(path)
-
-        for i, batch in enumerate(batched(test_ids, chunk_size)):
-            job_name = f'{name_base}_part{i}'
-            test_file_args = ' '.join(batch).strip().replace('\n', ' ')
-            diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
-            if yml is None:
-                yml = diff_yml
-            else:
-                yml.update(diff_yml)
-
-    keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
-    keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
-
-    k3_idxs = list(range(len(keras3_need_examples)))
-    k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
-
-    for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
-        batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
-        names = [path_to_name(path) for path in batch_paths]
-        name = 'keras3-' + '+'.join(names)
-        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-        batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
-        diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
-        yml.update(diff_yml)
+    # for batch_idxs in batched(idxs, n_test_files_per_yml):
+    #     batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
+    #     names = [path_to_name(path) for path in batch_paths]
+    #     name = '+'.join(names)
+    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+    #     batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
+    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
+    #     if yml is None:
+    #         yml = diff_yml
+    #     else:
+    #         yml.update(diff_yml)
+
+    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
+    # for path in test_paths:
+    #     name = path.stem.replace('test_', '')
+    #     test_file = str(path.relative_to(test_root))
+    #     needs_examples = uses_example_model(path)
+    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
+    #     yml.update(diff_yml)
+
+    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
+    # for path in test_paths:
+    #     stem = path.stem
+    #     name_base = stem.replace('test_', '')
+    #     test_file = str(path.relative_to(test_root))
+    #     test_ids = collect_test_functions_from_ast(test_file)
+    #     chunk_size = SPLIT_BY_TEST_CASE[stem]
+    #     needs_examples = uses_example_model(path)
+
+    #     for i, batch in enumerate(batched(test_ids, chunk_size)):
+    #         job_name = f'{name_base}_part{i}'
+    #         test_file_args = ' '.join(batch).strip().replace('\n', ' ')
+    #         diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
+    #         if yml is None:
+    #             yml = diff_yml
+    #         else:
+    #             yml.update(diff_yml)
+
+    # keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
+    # keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
+
+    # k3_idxs = list(range(len(keras3_need_examples)))
+    # k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
+
+    # for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
+    #     batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
+    #     names = [path_to_name(path) for path in batch_paths]
+    #     name = 'keras3-' + '+'.join(names)
+    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+    #     batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
+    #     diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
+    #     yml.update(diff_yml)
 
     qkeras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in QKERAS3_LIST]
     qkeras3_need_examples = [uses_example_model(path) for path in qkeras3_paths]
@@ -154,7 +154,8 @@ def generate_test_yaml(test_root='.'):
         test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
         batch_need_example_model = int(any([qkeras3_need_examples[i] for i in batch_idxs]))
         diff_yml = yaml.safe_load(template.format(name, '.pytest-qkeras-v3-only', test_files, batch_need_example_model))
-        yml.update(diff_yml)
+        yml = diff_yml
+        #yml.update(diff_yml)
 
     return yml
 

From b01c722b7576b9e7bc565578371e1c0e623eccea Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Wed, 20 May 2026 23:18:20 +0200
Subject: [PATCH 28/40] update env

---
 test/pytest/ci-template.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index 3d1a8912c2..0d23d71f2c 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -54,5 +54,5 @@
 .pytest-qkeras-v3-only:
   extends: .pytest
   variables:
-    CONDA_ENV: "hls4ml-testing-keras3"
-    EXTRA_DEPS: "[testing,testing-keras3,qkeras-v3]"
+    CONDA_ENV: "hls4ml-testing"
+    EXTRA_DEPS: "[qkeras-v3]"

From a6fac77048fa3ee2805b7ea2d7044d5850db9df0 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Wed, 20 May 2026 23:25:36 +0200
Subject: [PATCH 29/40] add back testing-keras3

---
 test/pytest/ci-template.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index 0d23d71f2c..95447997ca 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -54,5 +54,5 @@
 .pytest-qkeras-v3-only:
   extends: .pytest
   variables:
-    CONDA_ENV: "hls4ml-testing"
+    CONDA_ENV: "hls4ml-testing-keras3"
     EXTRA_DEPS: "[qkeras-v3]"

From f4342b0c77243df511d6b7bd0ae0b1cc1c25e8e0 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Thu, 21 May 2026 00:40:28 +0200
Subject: [PATCH 30/40] add back all tests

---
 test/pytest/generate_ci_yaml.py | 107 ++++++++++++++++----------------
 1 file changed, 53 insertions(+), 54 deletions(-)

diff --git a/test/pytest/generate_ci_yaml.py b/test/pytest/generate_ci_yaml.py
index f0d3d51464..a48bed9e7e 100644
--- a/test/pytest/generate_ci_yaml.py
+++ b/test/pytest/generate_ci_yaml.py
@@ -88,58 +88,58 @@ def generate_test_yaml(test_root='.'):
     idxs = sorted(idxs, key=lambda i: f'{need_example_models[i]}_{path_to_name(test_paths[i])}')
 
     yml = None
-    # for batch_idxs in batched(idxs, n_test_files_per_yml):
-    #     batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
-    #     names = [path_to_name(path) for path in batch_paths]
-    #     name = '+'.join(names)
-    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-    #     batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
-    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
-    #     if yml is None:
-    #         yml = diff_yml
-    #     else:
-    #         yml.update(diff_yml)
-
-    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
-    # for path in test_paths:
-    #     name = path.stem.replace('test_', '')
-    #     test_file = str(path.relative_to(test_root))
-    #     needs_examples = uses_example_model(path)
-    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
-    #     yml.update(diff_yml)
-
-    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
-    # for path in test_paths:
-    #     stem = path.stem
-    #     name_base = stem.replace('test_', '')
-    #     test_file = str(path.relative_to(test_root))
-    #     test_ids = collect_test_functions_from_ast(test_file)
-    #     chunk_size = SPLIT_BY_TEST_CASE[stem]
-    #     needs_examples = uses_example_model(path)
-
-    #     for i, batch in enumerate(batched(test_ids, chunk_size)):
-    #         job_name = f'{name_base}_part{i}'
-    #         test_file_args = ' '.join(batch).strip().replace('\n', ' ')
-    #         diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
-    #         if yml is None:
-    #             yml = diff_yml
-    #         else:
-    #             yml.update(diff_yml)
-
-    # keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
-    # keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
-
-    # k3_idxs = list(range(len(keras3_need_examples)))
-    # k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
-
-    # for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
-    #     batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
-    #     names = [path_to_name(path) for path in batch_paths]
-    #     name = 'keras3-' + '+'.join(names)
-    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-    #     batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
-    #     diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
-    #     yml.update(diff_yml)
+    for batch_idxs in batched(idxs, n_test_files_per_yml):
+        batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
+        names = [path_to_name(path) for path in batch_paths]
+        name = '+'.join(names)
+        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+        batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
+        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
+        if yml is None:
+            yml = diff_yml
+        else:
+            yml.update(diff_yml)
+
+    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
+    for path in test_paths:
+        name = path.stem.replace('test_', '')
+        test_file = str(path.relative_to(test_root))
+        needs_examples = uses_example_model(path)
+        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
+        yml.update(diff_yml)
+
+    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
+    for path in test_paths:
+        stem = path.stem
+        name_base = stem.replace('test_', '')
+        test_file = str(path.relative_to(test_root))
+        test_ids = collect_test_functions_from_ast(test_file)
+        chunk_size = SPLIT_BY_TEST_CASE[stem]
+        needs_examples = uses_example_model(path)
+
+        for i, batch in enumerate(batched(test_ids, chunk_size)):
+            job_name = f'{name_base}_part{i}'
+            test_file_args = ' '.join(batch).strip().replace('\n', ' ')
+            diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
+            if yml is None:
+                yml = diff_yml
+            else:
+                yml.update(diff_yml)
+
+    keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
+    keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
+
+    k3_idxs = list(range(len(keras3_need_examples)))
+    k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
+
+    for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
+        batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
+        names = [path_to_name(path) for path in batch_paths]
+        name = 'keras3-' + '+'.join(names)
+        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+        batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
+        diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
+        yml.update(diff_yml)
 
     qkeras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in QKERAS3_LIST]
     qkeras3_need_examples = [uses_example_model(path) for path in qkeras3_paths]
@@ -154,8 +154,7 @@ def generate_test_yaml(test_root='.'):
         test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
         batch_need_example_model = int(any([qkeras3_need_examples[i] for i in batch_idxs]))
         diff_yml = yaml.safe_load(template.format(name, '.pytest-qkeras-v3-only', test_files, batch_need_example_model))
-        yml = diff_yml
-        #yml.update(diff_yml)
+        yml.update(diff_yml)
 
     return yml
 

From edbbfe784dd231089e18ed5d20e000c004194007 Mon Sep 17 00:00:00 2001
From: Haris1299 <hmurugan@uni-mainz.de>
Date: Thu, 21 May 2026 00:48:10 +0200
Subject: [PATCH 31/40] try with safe_mode=False

---
 test/pytest/test_qkerasV3.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
index ebad3ecf2d..5630615381 100644
--- a/test/pytest/test_qkerasV3.py
+++ b/test/pytest/test_qkerasV3.py
@@ -62,7 +62,11 @@ def load_jettagging_model():
     Load the 3 hidden layer QKeras example model trained on the jet tagging dataset
     """
     model_path = example_model_path / 'keras/qkeras-v3_3layer.keras'
-    model = keras.saving.load_model(model_path, custom_objects=co)
+    model = keras.saving.load_model(
+        model_path,
+        custom_objects=co,
+        safe_mode=False,
+    )
     return model
 
 

From a5388f6e6d4f9d5a855163f5aec753caa1b7007d Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Thu, 21 May 2026 23:37:01 +0200
Subject: [PATCH 32/40] add compile=False

---
 test/pytest/generate_ci_yaml.py | 109 ++++++++++++++++----------------
 test/pytest/test_qkerasV3.py    |   1 +
 2 files changed, 56 insertions(+), 54 deletions(-)

diff --git a/test/pytest/generate_ci_yaml.py b/test/pytest/generate_ci_yaml.py
index a48bed9e7e..5d57db8270 100644
--- a/test/pytest/generate_ci_yaml.py
+++ b/test/pytest/generate_ci_yaml.py
@@ -88,58 +88,58 @@ def generate_test_yaml(test_root='.'):
     idxs = sorted(idxs, key=lambda i: f'{need_example_models[i]}_{path_to_name(test_paths[i])}')
 
     yml = None
-    for batch_idxs in batched(idxs, n_test_files_per_yml):
-        batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
-        names = [path_to_name(path) for path in batch_paths]
-        name = '+'.join(names)
-        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-        batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
-        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
-        if yml is None:
-            yml = diff_yml
-        else:
-            yml.update(diff_yml)
-
-    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
-    for path in test_paths:
-        name = path.stem.replace('test_', '')
-        test_file = str(path.relative_to(test_root))
-        needs_examples = uses_example_model(path)
-        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
-        yml.update(diff_yml)
-
-    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
-    for path in test_paths:
-        stem = path.stem
-        name_base = stem.replace('test_', '')
-        test_file = str(path.relative_to(test_root))
-        test_ids = collect_test_functions_from_ast(test_file)
-        chunk_size = SPLIT_BY_TEST_CASE[stem]
-        needs_examples = uses_example_model(path)
-
-        for i, batch in enumerate(batched(test_ids, chunk_size)):
-            job_name = f'{name_base}_part{i}'
-            test_file_args = ' '.join(batch).strip().replace('\n', ' ')
-            diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
-            if yml is None:
-                yml = diff_yml
-            else:
-                yml.update(diff_yml)
-
-    keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
-    keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
-
-    k3_idxs = list(range(len(keras3_need_examples)))
-    k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
-
-    for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
-        batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
-        names = [path_to_name(path) for path in batch_paths]
-        name = 'keras3-' + '+'.join(names)
-        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-        batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
-        diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
-        yml.update(diff_yml)
+    # for batch_idxs in batched(idxs, n_test_files_per_yml):
+    #     batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
+    #     names = [path_to_name(path) for path in batch_paths]
+    #     name = '+'.join(names)
+    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+    #     batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
+    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
+    #     if yml is None:
+    #         yml = diff_yml
+    #     else:
+    #         yml.update(diff_yml)
+
+    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
+    # for path in test_paths:
+    #     name = path.stem.replace('test_', '')
+    #     test_file = str(path.relative_to(test_root))
+    #     needs_examples = uses_example_model(path)
+    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
+    #     yml.update(diff_yml)
+
+    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
+    # for path in test_paths:
+    #     stem = path.stem
+    #     name_base = stem.replace('test_', '')
+    #     test_file = str(path.relative_to(test_root))
+    #     test_ids = collect_test_functions_from_ast(test_file)
+    #     chunk_size = SPLIT_BY_TEST_CASE[stem]
+    #     needs_examples = uses_example_model(path)
+
+    #     for i, batch in enumerate(batched(test_ids, chunk_size)):
+    #         job_name = f'{name_base}_part{i}'
+    #         test_file_args = ' '.join(batch).strip().replace('\n', ' ')
+    #         diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
+    #         if yml is None:
+    #             yml = diff_yml
+    #         else:
+    #             yml.update(diff_yml)
+
+    # keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
+    # keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
+
+    # k3_idxs = list(range(len(keras3_need_examples)))
+    # k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
+
+    # for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
+    #     batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
+    #     names = [path_to_name(path) for path in batch_paths]
+    #     name = 'keras3-' + '+'.join(names)
+    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+    #     batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
+    #     diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
+    #     yml.update(diff_yml)
 
     qkeras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in QKERAS3_LIST]
     qkeras3_need_examples = [uses_example_model(path) for path in qkeras3_paths]
@@ -151,10 +151,11 @@ def generate_test_yaml(test_root='.'):
         batch_paths: list[Path] = [qkeras3_paths[i] for i in batch_idxs]
         names = [path_to_name(path) for path in batch_paths]
         name = 'qkerasV3'
-        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths]) + "::test_accuracy"
         batch_need_example_model = int(any([qkeras3_need_examples[i] for i in batch_idxs]))
         diff_yml = yaml.safe_load(template.format(name, '.pytest-qkeras-v3-only', test_files, batch_need_example_model))
-        yml.update(diff_yml)
+        yml = diff_yml
+        #yml.update(diff_yml)
 
     return yml
 
diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
index 5630615381..73a59e5ae2 100644
--- a/test/pytest/test_qkerasV3.py
+++ b/test/pytest/test_qkerasV3.py
@@ -65,6 +65,7 @@ def load_jettagging_model():
     model = keras.saving.load_model(
         model_path,
         custom_objects=co,
+        compile=False,
         safe_mode=False,
     )
     return model

From 3766914807dc8e4bd3ffb9c53b085283cfdd57fc Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Thu, 21 May 2026 23:45:25 +0200
Subject: [PATCH 33/40] change packages

---
 pyproject.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index bb1c850036..b6b8ba6f58 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -74,9 +74,9 @@ optional-dependencies.testing-keras3 = [
   "tensorflow>=2.15",
 ]
 optional-dependencies.testing-qkeras-v3 = [
-  "keras>=3.10",
+  "keras==3.14.1",
   "qkeras-v3",
-  "tensorflow>=2.15",
+  "tensorflow>=2.21.0",
 ]
 urls.Homepage = "https://fastmachinelearning.org/hls4ml"
 scripts.hls4ml = "hls4ml.cli:main"

From 77e52bdd958f9c8bd9094d7b949335a3eeb32ec0 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Thu, 21 May 2026 23:52:21 +0200
Subject: [PATCH 34/40] update qkeras-v3 template

---
 test/pytest/ci-template.yml | 45 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index 95447997ca..e5e73e1677 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -52,7 +52,50 @@
     EXTRA_DEPS: "[da,testing,testing-keras3,sr]"
 
 .pytest-qkeras-v3-only:
-  extends: .pytest
+  stage: test
+  image: gitlab-registry.cern.ch/fastmachinelearning/hls4ml-testing:0.6.3.base
+  tags:
+    - k8s-default
   variables:
     CONDA_ENV: "hls4ml-testing-keras3"
     EXTRA_DEPS: "[qkeras-v3]"
+  before_script:
+    - eval "$(conda shell.bash hook)"
+    - conda activate "$CONDA_ENV"
+    - git config --global --add safe.directory /builds/fastmachinelearning/hls4ml
+    - git submodule update --init --recursive hls4ml/templates/catapult/
+    - if [ $EXAMPLEMODEL == 1 ]; then git submodule update --init example-models; fi
+    - pip uninstall tensorflow keras
+    - pip install .
+    - pip install qkeras-v3 tensorflow keras
+
+    # set up vivado_hls command
+    - mkdir -p cmd_vivado_${VIVADO_VERSION}
+    - echo '#!/bin/bash' > cmd_vivado_${VIVADO_VERSION}/vivado_hls
+    - echo "apptainer exec --cleanenv --env LANG=C,LC_ALL=C /cvmfs/projects.cern.ch/hls4ml/vivado/${VIVADO_VERSION} vivado_hls \"\$@\"" >> cmd_vivado_${VIVADO_VERSION}/vivado_hls
+    - chmod +x cmd_vivado_${VIVADO_VERSION}/vivado_hls
+    - export PATH=$PWD/cmd_vivado_${VIVADO_VERSION}:$PATH
+
+    # set up vitis-run command
+    - mkdir -p cmd_vitis_${VITIS_VERSION}
+    - echo '#!/bin/bash' > cmd_vitis_${VITIS_VERSION}/vitis-run
+    - echo "apptainer exec /cvmfs/projects.cern.ch/hls4ml/vitis/${VITIS_VERSION} vitis-run \"\$@\"" >> cmd_vitis_${VITIS_VERSION}/vitis-run
+    - chmod +x cmd_vitis_${VITIS_VERSION}/vitis-run
+    - export PATH=$PWD/cmd_vitis_${VITIS_VERSION}:$PATH
+
+    # Load Intel oneAPI environment variables
+    - source /opt/intel/oneapi/setvars.sh --force
+  script:
+    - cd test/pytest
+    - pytest $PYTESTFILE -rA --cov-report xml --cov-report term --cov=hls4ml --junitxml=report.xml --randomly-seed=42 --randomly-dont-reorganize --randomly-dont-reset-seed
+  artifacts:
+    when: always
+    reports:
+      junit:
+        - test/pytest/report.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: test/pytest/coverage.xml
+    paths:
+      - test/pytest/*.tar.gz
+      - test/pytest/synthesis_report_*.json

From 49faba7d4af0d6ec02174ad30abb15258924fdd3 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Thu, 21 May 2026 23:55:33 +0200
Subject: [PATCH 35/40] update script

---
 test/pytest/ci-template.yml | 41 ++-----------------------------------
 1 file changed, 2 insertions(+), 39 deletions(-)

diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index e5e73e1677..1ee7f14620 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -52,50 +52,13 @@
     EXTRA_DEPS: "[da,testing,testing-keras3,sr]"
 
 .pytest-qkeras-v3-only:
-  stage: test
-  image: gitlab-registry.cern.ch/fastmachinelearning/hls4ml-testing:0.6.3.base
-  tags:
-    - k8s-default
+  extends: .pytest
   variables:
     CONDA_ENV: "hls4ml-testing-keras3"
     EXTRA_DEPS: "[qkeras-v3]"
-  before_script:
-    - eval "$(conda shell.bash hook)"
-    - conda activate "$CONDA_ENV"
-    - git config --global --add safe.directory /builds/fastmachinelearning/hls4ml
-    - git submodule update --init --recursive hls4ml/templates/catapult/
-    - if [ $EXAMPLEMODEL == 1 ]; then git submodule update --init example-models; fi
+  script:
     - pip uninstall tensorflow keras
     - pip install .
     - pip install qkeras-v3 tensorflow keras
-
-    # set up vivado_hls command
-    - mkdir -p cmd_vivado_${VIVADO_VERSION}
-    - echo '#!/bin/bash' > cmd_vivado_${VIVADO_VERSION}/vivado_hls
-    - echo "apptainer exec --cleanenv --env LANG=C,LC_ALL=C /cvmfs/projects.cern.ch/hls4ml/vivado/${VIVADO_VERSION} vivado_hls \"\$@\"" >> cmd_vivado_${VIVADO_VERSION}/vivado_hls
-    - chmod +x cmd_vivado_${VIVADO_VERSION}/vivado_hls
-    - export PATH=$PWD/cmd_vivado_${VIVADO_VERSION}:$PATH
-
-    # set up vitis-run command
-    - mkdir -p cmd_vitis_${VITIS_VERSION}
-    - echo '#!/bin/bash' > cmd_vitis_${VITIS_VERSION}/vitis-run
-    - echo "apptainer exec /cvmfs/projects.cern.ch/hls4ml/vitis/${VITIS_VERSION} vitis-run \"\$@\"" >> cmd_vitis_${VITIS_VERSION}/vitis-run
-    - chmod +x cmd_vitis_${VITIS_VERSION}/vitis-run
-    - export PATH=$PWD/cmd_vitis_${VITIS_VERSION}:$PATH
-
-    # Load Intel oneAPI environment variables
-    - source /opt/intel/oneapi/setvars.sh --force
-  script:
     - cd test/pytest
     - pytest $PYTESTFILE -rA --cov-report xml --cov-report term --cov=hls4ml --junitxml=report.xml --randomly-seed=42 --randomly-dont-reorganize --randomly-dont-reset-seed
-  artifacts:
-    when: always
-    reports:
-      junit:
-        - test/pytest/report.xml
-      coverage_report:
-        coverage_format: cobertura
-        path: test/pytest/coverage.xml
-    paths:
-      - test/pytest/*.tar.gz
-      - test/pytest/synthesis_report_*.json

From 4febd2df4b31c1a2e5a4d755377a4d6f5036a24a Mon Sep 17 00:00:00 2001
From: mu3e <mu3e@mu3efarm0.mu3e>
Date: Fri, 22 May 2026 00:04:38 +0200
Subject: [PATCH 36/40] update tests

---
 test/pytest/ci-template.yml  | 6 ------
 test/pytest/test_qkerasV3.py | 9 +++++++++
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/test/pytest/ci-template.yml b/test/pytest/ci-template.yml
index 1ee7f14620..95447997ca 100644
--- a/test/pytest/ci-template.yml
+++ b/test/pytest/ci-template.yml
@@ -56,9 +56,3 @@
   variables:
     CONDA_ENV: "hls4ml-testing-keras3"
     EXTRA_DEPS: "[qkeras-v3]"
-  script:
-    - pip uninstall tensorflow keras
-    - pip install .
-    - pip install qkeras-v3 tensorflow keras
-    - cd test/pytest
-    - pytest $PYTESTFILE -rA --cov-report xml --cov-report term --cov=hls4ml --junitxml=report.xml --randomly-seed=42 --randomly-dont-reorganize --randomly-dont-reset-seed
diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
index 73a59e5ae2..27746b9f06 100644
--- a/test/pytest/test_qkerasV3.py
+++ b/test/pytest/test_qkerasV3.py
@@ -27,6 +27,15 @@
 
 import hls4ml
 
+
+_original_init = QDense.__init__
+
+def patched_init(self, *args, **kwargs):
+    kwargs.pop("quantization_config", None)
+    _original_init(self, *args, **kwargs)
+
+QDense.__init__ = patched_init
+
 co = {}
 _add_supported_quantized_objects(co)
 

From 6cd82d71441865b6b485b82a8e9eb6378ded9336 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Fri, 22 May 2026 00:15:37 +0200
Subject: [PATCH 37/40] ci

---
 test/pytest/generate_ci_yaml.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/pytest/generate_ci_yaml.py b/test/pytest/generate_ci_yaml.py
index 5d57db8270..118a3d4d74 100644
--- a/test/pytest/generate_ci_yaml.py
+++ b/test/pytest/generate_ci_yaml.py
@@ -155,6 +155,7 @@ def generate_test_yaml(test_root='.'):
         batch_need_example_model = int(any([qkeras3_need_examples[i] for i in batch_idxs]))
         diff_yml = yaml.safe_load(template.format(name, '.pytest-qkeras-v3-only', test_files, batch_need_example_model))
         yml = diff_yml
+        
         #yml.update(diff_yml)
 
     return yml

From 346a2a5262afb34af7d059bc85f4f56a8311438a Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Fri, 22 May 2026 00:27:07 +0200
Subject: [PATCH 38/40] ci

---
 pyproject.toml                  |  2 +-
 test/pytest/generate_ci_yaml.py |  1 -
 test/pytest/test_qkerasV3.py    | 25 +++++++++++++------------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index b6b8ba6f58..799235cab7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -76,7 +76,7 @@ optional-dependencies.testing-keras3 = [
 optional-dependencies.testing-qkeras-v3 = [
   "keras==3.14.1",
   "qkeras-v3",
-  "tensorflow>=2.21.0",
+  "tensorflow>=2.21",
 ]
 urls.Homepage = "https://fastmachinelearning.org/hls4ml"
 scripts.hls4ml = "hls4ml.cli:main"
diff --git a/test/pytest/generate_ci_yaml.py b/test/pytest/generate_ci_yaml.py
index 118a3d4d74..5d57db8270 100644
--- a/test/pytest/generate_ci_yaml.py
+++ b/test/pytest/generate_ci_yaml.py
@@ -155,7 +155,6 @@ def generate_test_yaml(test_root='.'):
         batch_need_example_model = int(any([qkeras3_need_examples[i] for i in batch_idxs]))
         diff_yml = yaml.safe_load(template.format(name, '.pytest-qkeras-v3-only', test_files, batch_need_example_model))
         yml = diff_yml
-        
         #yml.update(diff_yml)
 
     return yml
diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
index 27746b9f06..149166b23a 100644
--- a/test/pytest/test_qkerasV3.py
+++ b/test/pytest/test_qkerasV3.py
@@ -27,13 +27,14 @@
 
 import hls4ml
 
-
 _original_init = QDense.__init__
 
+
 def patched_init(self, *args, **kwargs):
-    kwargs.pop("quantization_config", None)
+    kwargs.pop('quantization_config', None)
     _original_init(self, *args, **kwargs)
 
+
 QDense.__init__ = patched_init
 
 co = {}
@@ -114,23 +115,23 @@ def test_accuracy(convert, load_jettagging_model, get_jettagging_data):
     print('Test accuracy')
     from sklearn.metrics import accuracy_score
 
-    X_train_val, X_test, y_train_val, y_test = get_jettagging_data
+    #X_train_val, X_test, y_train_val, y_test = get_jettagging_data
 
     hls_model = convert
     model = load_jettagging_model
 
-    y_qkeras = model.predict(np.ascontiguousarray(X_test))
-    y_hls4ml = hls_model.predict(np.ascontiguousarray(X_test))
+    # y_qkeras = model.predict(np.ascontiguousarray(X_test))
+    # y_hls4ml = hls_model.predict(np.ascontiguousarray(X_test))
 
-    acc_qkeras = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_qkeras, axis=1))
-    acc_hls4ml = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_hls4ml, axis=1))
-    rel_diff = abs(acc_qkeras - acc_hls4ml) / acc_qkeras
+    # acc_qkeras = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_qkeras, axis=1))
+    # acc_hls4ml = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_hls4ml, axis=1))
+    # rel_diff = abs(acc_qkeras - acc_hls4ml) / acc_qkeras
 
-    print(f'Accuracy qkeras:     {acc_qkeras}')
-    print(f'Accuracy hls4ml:     {acc_hls4ml}')
-    print(f'Relative difference: {rel_diff}')
+    # print(f'Accuracy qkeras:     {acc_qkeras}')
+    # print(f'Accuracy hls4ml:     {acc_hls4ml}')
+    # print(f'Relative difference: {rel_diff}')
 
-    assert acc_qkeras > 0.7 and rel_diff < 0.01
+    # assert acc_qkeras > 0.7 and rel_diff < 0.01
 
 
 def randX(batch_size, N):

From 70f01f5e326a35ba3672e80b1ddbf4f8aac76443 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Fri, 22 May 2026 00:32:54 +0200
Subject: [PATCH 39/40] ci

---
 test/pytest/test_qkerasV3.py | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
index 149166b23a..bb403b7c9d 100644
--- a/test/pytest/test_qkerasV3.py
+++ b/test/pytest/test_qkerasV3.py
@@ -48,22 +48,22 @@ def patched_init(self, *args, **kwargs):
 example_model_path = (test_root_path / '../../example-models').resolve()
 
 
-@pytest.fixture(scope='module')
-def get_jettagging_data():
-    """
-    Download the jet tagging dataset
-    """
-    print('Fetching data from openml')
-    data = fetch_openml('hls4ml_lhc_jets_hlf')
-    X, y = data['data'], data['target']
-    le = LabelEncoder()
-    y = le.fit_transform(y)
-    y = to_categorical(y, 5)
-    X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-    scaler = StandardScaler()
-    X_train_val = scaler.fit_transform(X_train_val)
-    X_test = scaler.transform(X_test)
-    return X_train_val, X_test, y_train_val, y_test
+# @pytest.fixture(scope='module')
+# def get_jettagging_data():
+#     """
+#     Download the jet tagging dataset
+#     """
+#     print('Fetching data from openml')
+#     data = fetch_openml('hls4ml_lhc_jets_hlf')
+#     X, y = data['data'], data['target']
+#     le = LabelEncoder()
+#     y = le.fit_transform(y)
+#     y = to_categorical(y, 5)
+#     X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+#     scaler = StandardScaler()
+#     X_train_val = scaler.fit_transform(X_train_val)
+#     X_test = scaler.transform(X_test)
+#     return X_train_val, X_test, y_train_val, y_test
 
 
 @pytest.fixture(scope='module')
@@ -106,7 +106,7 @@ def convert(load_jettagging_model, request, test_case_id):
 
 
 @pytest.mark.parametrize('convert', ['latency', 'resource'], indirect=True, ids=['latency', 'resource'])
-def test_accuracy(convert, load_jettagging_model, get_jettagging_data):
+def test_accuracy(convert, load_jettagging_model):
     """
     Test the hls4ml-evaluated accuracy of a 3 hidden layer QKeras model trained on
     the jet tagging dataset. QKeras model accuracy is required to be over 70%, and

From 9f0edd9304b8c27a795bfe51f4e465c27d416ec3 Mon Sep 17 00:00:00 2001
From: makoeppel <koeppel.ma@googlemail.com>
Date: Fri, 22 May 2026 00:36:56 +0200
Subject: [PATCH 40/40] revert ci scripts

---
 test/pytest/generate_ci_yaml.py | 109 ++++++++++++++++----------------
 test/pytest/test_qkerasV3.py    |  54 ++++++++--------
 2 files changed, 81 insertions(+), 82 deletions(-)

diff --git a/test/pytest/generate_ci_yaml.py b/test/pytest/generate_ci_yaml.py
index 5d57db8270..a48bed9e7e 100644
--- a/test/pytest/generate_ci_yaml.py
+++ b/test/pytest/generate_ci_yaml.py
@@ -88,58 +88,58 @@ def generate_test_yaml(test_root='.'):
     idxs = sorted(idxs, key=lambda i: f'{need_example_models[i]}_{path_to_name(test_paths[i])}')
 
     yml = None
-    # for batch_idxs in batched(idxs, n_test_files_per_yml):
-    #     batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
-    #     names = [path_to_name(path) for path in batch_paths]
-    #     name = '+'.join(names)
-    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-    #     batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
-    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
-    #     if yml is None:
-    #         yml = diff_yml
-    #     else:
-    #         yml.update(diff_yml)
-
-    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
-    # for path in test_paths:
-    #     name = path.stem.replace('test_', '')
-    #     test_file = str(path.relative_to(test_root))
-    #     needs_examples = uses_example_model(path)
-    #     diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
-    #     yml.update(diff_yml)
-
-    # test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
-    # for path in test_paths:
-    #     stem = path.stem
-    #     name_base = stem.replace('test_', '')
-    #     test_file = str(path.relative_to(test_root))
-    #     test_ids = collect_test_functions_from_ast(test_file)
-    #     chunk_size = SPLIT_BY_TEST_CASE[stem]
-    #     needs_examples = uses_example_model(path)
-
-    #     for i, batch in enumerate(batched(test_ids, chunk_size)):
-    #         job_name = f'{name_base}_part{i}'
-    #         test_file_args = ' '.join(batch).strip().replace('\n', ' ')
-    #         diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
-    #         if yml is None:
-    #             yml = diff_yml
-    #         else:
-    #             yml.update(diff_yml)
-
-    # keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
-    # keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
-
-    # k3_idxs = list(range(len(keras3_need_examples)))
-    # k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
-
-    # for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
-    #     batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
-    #     names = [path_to_name(path) for path in batch_paths]
-    #     name = 'keras3-' + '+'.join(names)
-    #     test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
-    #     batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
-    #     diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
-    #     yml.update(diff_yml)
+    for batch_idxs in batched(idxs, n_test_files_per_yml):
+        batch_paths: list[Path] = [test_paths[i] for i in batch_idxs]
+        names = [path_to_name(path) for path in batch_paths]
+        name = '+'.join(names)
+        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+        batch_need_example_model = int(any([need_example_models[i] for i in batch_idxs]))
+        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_files, batch_need_example_model))
+        if yml is None:
+            yml = diff_yml
+        else:
+            yml.update(diff_yml)
+
+    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in LONGLIST]
+    for path in test_paths:
+        name = path.stem.replace('test_', '')
+        test_file = str(path.relative_to(test_root))
+        needs_examples = uses_example_model(path)
+        diff_yml = yaml.safe_load(template.format(name, '.pytest', test_file, int(needs_examples)))
+        yml.update(diff_yml)
+
+    test_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in SPLIT_BY_TEST_CASE]
+    for path in test_paths:
+        stem = path.stem
+        name_base = stem.replace('test_', '')
+        test_file = str(path.relative_to(test_root))
+        test_ids = collect_test_functions_from_ast(test_file)
+        chunk_size = SPLIT_BY_TEST_CASE[stem]
+        needs_examples = uses_example_model(path)
+
+        for i, batch in enumerate(batched(test_ids, chunk_size)):
+            job_name = f'{name_base}_part{i}'
+            test_file_args = ' '.join(batch).strip().replace('\n', ' ')
+            diff_yml = yaml.safe_load(template.format(job_name, '.pytest', test_file_args, int(needs_examples)))
+            if yml is None:
+                yml = diff_yml
+            else:
+                yml.update(diff_yml)
+
+    keras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in KERAS3_LIST]
+    keras3_need_examples = [uses_example_model(path) for path in keras3_paths]
+
+    k3_idxs = list(range(len(keras3_need_examples)))
+    k3_idxs = sorted(k3_idxs, key=lambda i: f'{keras3_need_examples[i]}_{path_to_name(keras3_paths[i])}')
+
+    for batch_idxs in batched(k3_idxs, n_test_files_per_yml):
+        batch_paths: list[Path] = [keras3_paths[i] for i in batch_idxs]
+        names = [path_to_name(path) for path in batch_paths]
+        name = 'keras3-' + '+'.join(names)
+        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
+        batch_need_example_model = int(any([keras3_need_examples[i] for i in batch_idxs]))
+        diff_yml = yaml.safe_load(template.format(name, '.pytest-keras3-only', test_files, batch_need_example_model))
+        yml.update(diff_yml)
 
     qkeras3_paths = [path for path in test_root.glob('**/test_*.py') if path.stem in QKERAS3_LIST]
     qkeras3_need_examples = [uses_example_model(path) for path in qkeras3_paths]
@@ -151,11 +151,10 @@ def generate_test_yaml(test_root='.'):
         batch_paths: list[Path] = [qkeras3_paths[i] for i in batch_idxs]
         names = [path_to_name(path) for path in batch_paths]
         name = 'qkerasV3'
-        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths]) + "::test_accuracy"
+        test_files = ' '.join([str(path.relative_to(test_root)) for path in batch_paths])
         batch_need_example_model = int(any([qkeras3_need_examples[i] for i in batch_idxs]))
         diff_yml = yaml.safe_load(template.format(name, '.pytest-qkeras-v3-only', test_files, batch_need_example_model))
-        yml = diff_yml
-        #yml.update(diff_yml)
+        yml.update(diff_yml)
 
     return yml
 
diff --git a/test/pytest/test_qkerasV3.py b/test/pytest/test_qkerasV3.py
index bb403b7c9d..cd9429108b 100644
--- a/test/pytest/test_qkerasV3.py
+++ b/test/pytest/test_qkerasV3.py
@@ -48,22 +48,22 @@ def patched_init(self, *args, **kwargs):
 example_model_path = (test_root_path / '../../example-models').resolve()
 
 
-# @pytest.fixture(scope='module')
-# def get_jettagging_data():
-#     """
-#     Download the jet tagging dataset
-#     """
-#     print('Fetching data from openml')
-#     data = fetch_openml('hls4ml_lhc_jets_hlf')
-#     X, y = data['data'], data['target']
-#     le = LabelEncoder()
-#     y = le.fit_transform(y)
-#     y = to_categorical(y, 5)
-#     X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-#     scaler = StandardScaler()
-#     X_train_val = scaler.fit_transform(X_train_val)
-#     X_test = scaler.transform(X_test)
-#     return X_train_val, X_test, y_train_val, y_test
+@pytest.fixture(scope='module')
+def get_jettagging_data():
+    """
+    Download the jet tagging dataset
+    """
+    print('Fetching data from openml')
+    data = fetch_openml('hls4ml_lhc_jets_hlf')
+    X, y = data['data'], data['target']
+    le = LabelEncoder()
+    y = le.fit_transform(y)
+    y = to_categorical(y, 5)
+    X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    scaler = StandardScaler()
+    X_train_val = scaler.fit_transform(X_train_val)
+    X_test = scaler.transform(X_test)
+    return X_train_val, X_test, y_train_val, y_test
 
 
 @pytest.fixture(scope='module')
@@ -106,7 +106,7 @@ def convert(load_jettagging_model, request, test_case_id):
 
 
 @pytest.mark.parametrize('convert', ['latency', 'resource'], indirect=True, ids=['latency', 'resource'])
-def test_accuracy(convert, load_jettagging_model):
+def test_accuracy(convert, load_jettagging_model, get_jettagging_data):
     """
     Test the hls4ml-evaluated accuracy of a 3 hidden layer QKeras model trained on
     the jet tagging dataset. QKeras model accuracy is required to be over 70%, and
@@ -115,23 +115,23 @@ def test_accuracy(convert, load_jettagging_model):
     print('Test accuracy')
     from sklearn.metrics import accuracy_score
 
-    #X_train_val, X_test, y_train_val, y_test = get_jettagging_data
+    X_train_val, X_test, y_train_val, y_test = get_jettagging_data
 
     hls_model = convert
     model = load_jettagging_model
 
-    # y_qkeras = model.predict(np.ascontiguousarray(X_test))
-    # y_hls4ml = hls_model.predict(np.ascontiguousarray(X_test))
+    y_qkeras = model.predict(np.ascontiguousarray(X_test))
+    y_hls4ml = hls_model.predict(np.ascontiguousarray(X_test))
 
-    # acc_qkeras = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_qkeras, axis=1))
-    # acc_hls4ml = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_hls4ml, axis=1))
-    # rel_diff = abs(acc_qkeras - acc_hls4ml) / acc_qkeras
+    acc_qkeras = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_qkeras, axis=1))
+    acc_hls4ml = accuracy_score(np.argmax(y_test, axis=1), np.argmax(y_hls4ml, axis=1))
+    rel_diff = abs(acc_qkeras - acc_hls4ml) / acc_qkeras
 
-    # print(f'Accuracy qkeras:     {acc_qkeras}')
-    # print(f'Accuracy hls4ml:     {acc_hls4ml}')
-    # print(f'Relative difference: {rel_diff}')
+    print(f'Accuracy qkeras:     {acc_qkeras}')
+    print(f'Accuracy hls4ml:     {acc_hls4ml}')
+    print(f'Relative difference: {rel_diff}')
 
-    # assert acc_qkeras > 0.7 and rel_diff < 0.01
+    assert acc_qkeras > 0.7 and rel_diff < 0.01
 
 
 def randX(batch_size, N):