sparsepixels 0.2.1__tar.gz → 0.2.3__tar.gz

{sparsepixels-0.2.1/sparsepixels.egg-info → sparsepixels-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sparsepixels
-Version: 0.2.1
+Version: 0.2.3
 Summary: Efficient convolution for sparse data on FPGAs
 Home-page: https://github.com/hftsoi/sparse-pixels
 Author: Ho Fung Tsoi
@@ -13,7 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tensorflow
 Requires-Dist: keras>=3.0
-Requires-Dist: HGQ2
+Requires-Dist: HGQ2>=0.1.8
 Dynamic: license-file
 
 <p align="center">
@@ -50,40 +50,73 @@ Import sparse layers and quantization library (HGQ2):
 
 ```python
 import keras
-from keras.layers import Flatten, Activation, ReLU
+from keras.layers import Flatten, Activation
 from hgq.layers import QConv2D, QDense
 from hgq.config import QuantizerConfigScope, LayerConfigScope
+from hgq.quantizer.config import QuantizerConfig
 from sparsepixels.layers import InputReduce, QConv2DSparse, AveragePooling2DSparse
 ```
 
-Build an example sparse CNN within HGQ2 quantization scopes:
+Build an example sparse CNN within HGQ2 quantization scopes. A custom input quantizer
+config with higher initial fractional bits (`f0=8`) is used to prevent the default (`f0=2`)
+from zeroing out sparse signals in early training epochs:
 
 ```python
+iq_conf = QuantizerConfig(place='datalane', q_type='kif', i0=4, f0=8, overflow_mode='WRAP')
+
 with (
     QuantizerConfigScope(place='all', default_q_type='kbi', overflow_mode='SAT_SYM'),
     QuantizerConfigScope(place='datalane', default_q_type='kif', overflow_mode='WRAP'),
-    LayerConfigScope(enable_ebops=False, enable_iq=False),
+    LayerConfigScope(enable_ebops=True, enable_iq=True, beta0=1e-5),
 ):
-    x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), name='x_in')
+    x_in = keras.Input(shape=(28, 28, 1), name='x_in')
 
     # Sparse input reduction: retain up to n_max_pixels active pixels
     x, keep_mask = InputReduce(n_max_pixels=20, threshold=0.1, name='input_reduce')(x_in)
 
     # Sparse convolution
-    x = QConv2DSparse(filters=3, kernel_size=3, name='conv1', padding='same', strides=1)([x, keep_mask])
-    x = ReLU(name='relu1')(x)
+    x = QConv2DSparse(filters=3, kernel_size=3, name='conv1', padding='same', strides=1,
+                      activation='relu', iq_conf=iq_conf)([x, keep_mask])
 
     # Sparse pooling
     x, keep_mask = AveragePooling2DSparse(2, name='pool1')([x, keep_mask])
 
     x = Flatten(name='flatten')(x)
-    x = QDense(10, name='dense1', activation='relu')(x)
+    x = QDense(10, name='dense1', activation='relu', iq_conf=iq_conf)(x)
     x = Activation('softmax', name='softmax')(x)
 
 model = keras.Model(x_in, x)
 ```
 
-We are working on hls4ml integration that auto parses the sparse layers into HLS.
+## Converting a trained model to HLS with hls4ml
+
+> **Note:** A [PR](https://github.com/fastmachinelearning/hls4ml/pull/1468) adding `sparsepixels` support to the official [hls4ml](https://github.com/fastmachinelearning/hls4ml) repo has been submitted but is not yet merged. In the meantime you can install hls4ml from the PR branch on this fork to try the converter:
+>
+> ```bash
+> pip install "git+https://github.com/hftsoi/hls4ml.git@sparsepixels"
+> ```
+
+Once installed, converting a trained sparsepixels model to HLS is as usual:
+
+```python
+import hls4ml
+
+hls_config = hls4ml.utils.config_from_keras_model(model, granularity='name')
+hls_config.setdefault('Model', {})['PipelineStyle'] = 'dataflow'  # use "#pragma HLS DATAFLOW" (instead of the default "#pragma HLS PIPELINE" for io_parallel)
+
+hls_model = hls4ml.converters.convert_from_keras_model(
+    model,
+    hls_config=hls_config,
+    output_dir='hls_proj/my_sparse_cnn',
+    backend='Vitis',
+    io_type='io_parallel',  # io_stream is not supported yet
+)
+hls_model.write()
+hls_model.compile()
+y_hls = hls_model.predict(x_test)
+```
+
+> **Note:** The converter currently supports only fully parallelized `io_parallel` HLS. We are working on expanding to partial parallelization and `io_stream` for larger flexibility.
 
 ## Documentation
 

{sparsepixels-0.2.1 → sparsepixels-0.2.3}/README.md

@@ -32,40 +32,73 @@ Import sparse layers and quantization library (HGQ2):
 
 ```python
 import keras
-from keras.layers import Flatten, Activation, ReLU
+from keras.layers import Flatten, Activation
 from hgq.layers import QConv2D, QDense
 from hgq.config import QuantizerConfigScope, LayerConfigScope
+from hgq.quantizer.config import QuantizerConfig
 from sparsepixels.layers import InputReduce, QConv2DSparse, AveragePooling2DSparse
 ```
 
-Build an example sparse CNN within HGQ2 quantization scopes:
+Build an example sparse CNN within HGQ2 quantization scopes. A custom input quantizer
+config with higher initial fractional bits (`f0=8`) is used to prevent the default (`f0=2`)
+from zeroing out sparse signals in early training epochs:
 
 ```python
+iq_conf = QuantizerConfig(place='datalane', q_type='kif', i0=4, f0=8, overflow_mode='WRAP')
+
 with (
     QuantizerConfigScope(place='all', default_q_type='kbi', overflow_mode='SAT_SYM'),
     QuantizerConfigScope(place='datalane', default_q_type='kif', overflow_mode='WRAP'),
-    LayerConfigScope(enable_ebops=False, enable_iq=False),
+    LayerConfigScope(enable_ebops=True, enable_iq=True, beta0=1e-5),
 ):
-    x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), name='x_in')
+    x_in = keras.Input(shape=(28, 28, 1), name='x_in')
 
     # Sparse input reduction: retain up to n_max_pixels active pixels
     x, keep_mask = InputReduce(n_max_pixels=20, threshold=0.1, name='input_reduce')(x_in)
 
     # Sparse convolution
-    x = QConv2DSparse(filters=3, kernel_size=3, name='conv1', padding='same', strides=1)([x, keep_mask])
-    x = ReLU(name='relu1')(x)
+    x = QConv2DSparse(filters=3, kernel_size=3, name='conv1', padding='same', strides=1,
+                      activation='relu', iq_conf=iq_conf)([x, keep_mask])
 
     # Sparse pooling
     x, keep_mask = AveragePooling2DSparse(2, name='pool1')([x, keep_mask])
 
     x = Flatten(name='flatten')(x)
-    x = QDense(10, name='dense1', activation='relu')(x)
+    x = QDense(10, name='dense1', activation='relu', iq_conf=iq_conf)(x)
     x = Activation('softmax', name='softmax')(x)
 
 model = keras.Model(x_in, x)
 ```
 
-We are working on hls4ml integration that auto parses the sparse layers into HLS.
+## Converting a trained model to HLS with hls4ml
+
+> **Note:** A [PR](https://github.com/fastmachinelearning/hls4ml/pull/1468) adding `sparsepixels` support to the official [hls4ml](https://github.com/fastmachinelearning/hls4ml) repo has been submitted but is not yet merged. In the meantime you can install hls4ml from the PR branch on this fork to try the converter:
+>
+> ```bash
+> pip install "git+https://github.com/hftsoi/hls4ml.git@sparsepixels"
+> ```
+
+Once installed, converting a trained sparsepixels model to HLS is as usual:
+
+```python
+import hls4ml
+
+hls_config = hls4ml.utils.config_from_keras_model(model, granularity='name')
+hls_config.setdefault('Model', {})['PipelineStyle'] = 'dataflow'  # use "#pragma HLS DATAFLOW" (instead of the default "#pragma HLS PIPELINE" for io_parallel)
+
+hls_model = hls4ml.converters.convert_from_keras_model(
+    model,
+    hls_config=hls_config,
+    output_dir='hls_proj/my_sparse_cnn',
+    backend='Vitis',
+    io_type='io_parallel',  # io_stream is not supported yet
+)
+hls_model.write()
+hls_model.compile()
+y_hls = hls_model.predict(x_test)
+```
+
+> **Note:** The converter currently supports only fully parallelized `io_parallel` HLS. We are working on expanding to partial parallelization and `io_stream` for larger flexibility.
 
 ## Documentation
 

{sparsepixels-0.2.1 → sparsepixels-0.2.3}/notebook/utils.py

@@ -1149,3 +1149,101 @@ def preview_patches_with_pooling(
             plt.show()
 
 
+def _fmt_bits(bits_tensor):
+    b = np.array(bits_tensor).flatten()
+    if b.size == 1:
+        v = f"{b[0]:.1f}"
+        return v, v, v
+    return f"{np.mean(b):.1f}", f"{np.min(b):.1f}", f"{np.max(b):.1f}"
+
+def _get_layer_info(layer):
+    if hasattr(layer, 'conv') and hasattr(layer.conv, '_kq'):
+        core = layer.conv
+        kernel = core.kernel
+        bias = getattr(layer, 'sparse_bias', None)
+        bq = getattr(layer, '_bq', None)
+    elif hasattr(layer, '_kq'):
+        core = layer
+        kernel = core.kernel
+        bias = core.bias if core.use_bias else None
+        bq = getattr(core, '_bq', None)
+    else:
+        return None
+    kq = getattr(core, '_kq', None)
+    iq = getattr(core, '_iq', None)
+    ebops = float(core._ebops) if getattr(core, '_ebops', None) is not None else None
+    return dict(name=layer.name, n_kernel=int(np.prod(kernel.shape)),
+                n_bias=int(np.prod(bias.shape)) if bias is not None else 0,
+                kq=kq, bq=bq, iq=iq, ebops=ebops)
+
+def print_quantization(model):
+    print(f"\nModel: {model.name}")
+    h = (f"{'Layer':<12} {'#Kernel':>8} {'#Bias':>6}"
+         f"  {'K mean':>6} {'min':>5} {'max':>5}"
+         f"  {'B mean':>6} {'min':>5} {'max':>5}"
+         f"  {'I mean':>6} {'min':>5} {'max':>5}"
+         f"  {'eBOPs':>8}")
+    print(h)
+    print("-" * len(h))
+    total_ebops = 0
+    for layer in model.layers:
+        info = _get_layer_info(layer)
+        if info is None:
+            continue
+        km, klo, khi = _fmt_bits(info['kq'].bits) if info['kq'] else ("-", "-", "-")
+        bm, blo, bhi = _fmt_bits(info['bq'].bits) if info['bq'] else ("-", "-", "-")
+        im, ilo, ihi = _fmt_bits(info['iq'].bits) if info['iq'] else ("-", "-", "-")
+        if info['ebops'] is not None:
+            total_ebops += info['ebops']
+            es = f"{info['ebops']:.0f}"
+        else:
+            es = "-"
+        print(f"{info['name']:<12} {info['n_kernel']:>8} {info['n_bias']:>6}"
+              f"  {km:>6} {klo:>5} {khi:>5}"
+              f"  {bm:>6} {blo:>5} {bhi:>5}"
+              f"  {im:>6} {ilo:>5} {ihi:>5}"
+              f"  {es:>8}")
+    print("-" * len(h))
+    print(f"{'Total eBOPs':>{len(h)-8}}{total_ebops:>8.0f}")
+
+
+def plot_quantization(models, figsize=(14, 3)):
+    categories = [
+        ('kq', 'Kernel bits'),
+        ('bq', 'Bias bits'),
+        ('iq', 'Input bits'),
+    ]
+    fig, axes = plt.subplots(len(models), len(categories),
+                             figsize=(figsize[0], figsize[1] * len(models)),
+                             squeeze=False, constrained_layout=True)
+    for row, model in enumerate(models):
+        infos = [(info['name'], info) for layer in model.layers
+                 if (info := _get_layer_info(layer)) is not None]
+        colors = plt.cm.tab10(np.linspace(0, 1, max(len(infos), 1)))
+        for col, (key, title) in enumerate(categories):
+            ax = axes[row][col]
+            names, data = [], []
+            for (name, info), color in zip(infos, colors):
+                q = info[key]
+                if q is None:
+                    continue
+                names.append(name)
+                data.append(np.array(q.bits).flatten())
+            if not data:
+                ax.text(0.5, 0.5, 'N/A', transform=ax.transAxes,
+                        ha='center', va='center', fontsize=14, color='gray')
+                ax.set_title(f'{model.name} — {title}')
+                continue
+            parts = ax.violinplot(data, positions=range(len(data)), vert=False,
+                                  showmedians=True, showextrema=False)
+            used_colors = [c for (_, info), c in zip(infos, colors) if info[key] is not None]
+            for body, c in zip(parts['bodies'], used_colors):
+                body.set_facecolor(c)
+                body.set_alpha(0.7)
+            parts['cmedians'].set_color('black')
+            ax.set_yticks(range(len(names)))
+            ax.set_yticklabels(names)
+            ax.set_xlabel('Bitwidth')
+            ax.set_xlim(-0.5, 6.5)
+            ax.set_title(f'{model.name} — {title}')
+    plt.show()

{sparsepixels-0.2.1 → sparsepixels-0.2.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = sparsepixels
-version = 0.2.1
+version = 0.2.3
 description = Efficient convolution for sparse data on FPGAs
 author = Ho Fung Tsoi
 author_email = ho.fung.tsoi@cern.ch
@@ -19,7 +19,7 @@ python_requires = >=3.10
 install_requires = 
 	tensorflow
 	keras>=3.0
-	HGQ2
+	HGQ2>=0.1.8
 include_package_data = True
 
 [options.package_data]

{sparsepixels-0.2.1 → sparsepixels-0.2.3}/sparsepixels/layers.py

@@ -64,13 +64,21 @@ class QConv2DSparse(keras.layers.Layer):
         super().__init__(name=conv_kwargs.get("name", None))
         self._use_bias = conv_kwargs.pop("use_bias", True)
         self._bq_conf = conv_kwargs.pop("bq_conf", None) or QuantizerConfig("default", "bias")
+        self._activation = keras.activations.get(conv_kwargs.pop("activation", None))
 
         conv_kwargs["use_bias"] = False
-        conv_kwargs.setdefault("enable_iq", False)
+        conv_kwargs["activation"] = None
         self.conv = QConv2D(*conv_args, **conv_kwargs)
         self.masker = RemoveDilatedPixels()
 
     def build(self, input_shape):
+        # Build the wrapped conv here (eagerly, during layer build) instead of lazily inside call().
+        # Otherwise, when Keras traces call() symbolically to infer the output shape, the conv would
+        # build in graph mode and HGQ2 (>=0.1.9) runs a weight check there that evaluates a tensor as
+        # a Python bool -- which is not allowed in graph mode. See also compute_output_shape below.
+        x_shape = input_shape[0]
+        if not self.conv.built:
+            self.conv.build(x_shape)
         if self._use_bias:
             self.sparse_bias = self.add_weight(
                 name="sparse_bias",
@@ -82,6 +90,11 @@ class QConv2DSparse(keras.layers.Layer):
             self._bq.build((self.conv.filters,))
         super().build(input_shape)
 
+    def compute_output_shape(self, input_shape):
+        # Provide the output shape directly so Keras does not trace call() symbolically (masking
+        # preserves shape, so the output shape is the wrapped conv's output shape).
+        return self.conv.compute_output_shape(input_shape[0])
+
     def call(self, inputs, **kwargs):
         x, keep_mask = inputs
         x = self.masker((x, keep_mask))
@@ -93,6 +106,9 @@ class QConv2DSparse(keras.layers.Layer):
             non_zero = ops.cast(y != 0, y.dtype)
             y = y + b * non_zero
 
+        if self._activation is not None:
+            y = self._activation(y)
+
         y = self.masker((y, keep_mask))
         return y
 
@@ -101,6 +117,7 @@ class QConv2DSparse(keras.layers.Layer):
         cfg["conv_config"] = self.conv.get_config()
         cfg["use_bias"] = self._use_bias
         cfg["bq_conf"] = self._bq_conf
+        cfg["activation"] = keras.activations.serialize(self._activation)
         return cfg
 
     @classmethod
@@ -108,7 +125,8 @@ class QConv2DSparse(keras.layers.Layer):
         conv_cfg = config.pop("conv_config")
         use_bias = config.pop("use_bias", True)
         bq_conf = config.pop("bq_conf", None)
-        return cls(**conv_cfg, use_bias=use_bias, bq_conf=bq_conf)
+        activation = config.pop("activation", None)
+        return cls(**conv_cfg, use_bias=use_bias, bq_conf=bq_conf, activation=activation)
 
 
 class AveragePooling2DSparse(keras.layers.Layer):

{sparsepixels-0.2.1 → sparsepixels-0.2.3/sparsepixels.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sparsepixels
-Version: 0.2.1
+Version: 0.2.3
 Summary: Efficient convolution for sparse data on FPGAs
 Home-page: https://github.com/hftsoi/sparse-pixels
 Author: Ho Fung Tsoi
@@ -13,7 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tensorflow
 Requires-Dist: keras>=3.0
-Requires-Dist: HGQ2
+Requires-Dist: HGQ2>=0.1.8
 Dynamic: license-file
 
 <p align="center">
@@ -50,40 +50,73 @@ Import sparse layers and quantization library (HGQ2):
 
 ```python
 import keras
-from keras.layers import Flatten, Activation, ReLU
+from keras.layers import Flatten, Activation
 from hgq.layers import QConv2D, QDense
 from hgq.config import QuantizerConfigScope, LayerConfigScope
+from hgq.quantizer.config import QuantizerConfig
 from sparsepixels.layers import InputReduce, QConv2DSparse, AveragePooling2DSparse
 ```
 
-Build an example sparse CNN within HGQ2 quantization scopes:
+Build an example sparse CNN within HGQ2 quantization scopes. A custom input quantizer
+config with higher initial fractional bits (`f0=8`) is used to prevent the default (`f0=2`)
+from zeroing out sparse signals in early training epochs:
 
 ```python
+iq_conf = QuantizerConfig(place='datalane', q_type='kif', i0=4, f0=8, overflow_mode='WRAP')
+
 with (
     QuantizerConfigScope(place='all', default_q_type='kbi', overflow_mode='SAT_SYM'),
     QuantizerConfigScope(place='datalane', default_q_type='kif', overflow_mode='WRAP'),
-    LayerConfigScope(enable_ebops=False, enable_iq=False),
+    LayerConfigScope(enable_ebops=True, enable_iq=True, beta0=1e-5),
 ):
-    x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), name='x_in')
+    x_in = keras.Input(shape=(28, 28, 1), name='x_in')
 
     # Sparse input reduction: retain up to n_max_pixels active pixels
     x, keep_mask = InputReduce(n_max_pixels=20, threshold=0.1, name='input_reduce')(x_in)
 
     # Sparse convolution
-    x = QConv2DSparse(filters=3, kernel_size=3, name='conv1', padding='same', strides=1)([x, keep_mask])
-    x = ReLU(name='relu1')(x)
+    x = QConv2DSparse(filters=3, kernel_size=3, name='conv1', padding='same', strides=1,
+                      activation='relu', iq_conf=iq_conf)([x, keep_mask])
 
     # Sparse pooling
     x, keep_mask = AveragePooling2DSparse(2, name='pool1')([x, keep_mask])
 
     x = Flatten(name='flatten')(x)
-    x = QDense(10, name='dense1', activation='relu')(x)
+    x = QDense(10, name='dense1', activation='relu', iq_conf=iq_conf)(x)
     x = Activation('softmax', name='softmax')(x)
 
 model = keras.Model(x_in, x)
 ```
 
-We are working on hls4ml integration that auto parses the sparse layers into HLS.
+## Converting a trained model to HLS with hls4ml
+
+> **Note:** A [PR](https://github.com/fastmachinelearning/hls4ml/pull/1468) adding `sparsepixels` support to the official [hls4ml](https://github.com/fastmachinelearning/hls4ml) repo has been submitted but is not yet merged. In the meantime you can install hls4ml from the PR branch on this fork to try the converter:
+>
+> ```bash
+> pip install "git+https://github.com/hftsoi/hls4ml.git@sparsepixels"
+> ```
+
+Once installed, converting a trained sparsepixels model to HLS is as usual:
+
+```python
+import hls4ml
+
+hls_config = hls4ml.utils.config_from_keras_model(model, granularity='name')
+hls_config.setdefault('Model', {})['PipelineStyle'] = 'dataflow'  # use "#pragma HLS DATAFLOW" (instead of the default "#pragma HLS PIPELINE" for io_parallel)
+
+hls_model = hls4ml.converters.convert_from_keras_model(
+    model,
+    hls_config=hls_config,
+    output_dir='hls_proj/my_sparse_cnn',
+    backend='Vitis',
+    io_type='io_parallel',  # io_stream is not supported yet
+)
+hls_model.write()
+hls_model.compile()
+y_hls = hls_model.predict(x_test)
+```
+
+> **Note:** The converter currently supports only fully parallelized `io_parallel` HLS. We are working on expanding to partial parallelization and `io_stream` for larger flexibility.
 
 ## Documentation
 

{sparsepixels-0.2.1 → sparsepixels-0.2.3}/sparsepixels.egg-info/requires.txt

@@ -1,3 +1,3 @@
 tensorflow
 keras>=3.0
-HGQ2
+HGQ2>=0.1.8

{sparsepixels-0.2.1 → sparsepixels-0.2.3}/sparsepixels.egg-info/top_level.txt

@@ -1,8 +1,6 @@
 dist
 docs
-hls_proj
 hls_templates
 notebook
 sparsepixels
 tests
-weights

{sparsepixels-0.2.1 → sparsepixels-0.2.3}/tests/test_model.py

@@ -1,15 +1,17 @@
 import keras
-from keras.layers import Flatten, Activation, AveragePooling2D, ReLU
+from keras.layers import Flatten, Activation, AveragePooling2D
 from hgq.layers import QConv2D, QDense
 from hgq.config import QuantizerConfigScope, LayerConfigScope
+from hgq.quantizer.config import QuantizerConfig
 from sparsepixels.layers import InputReduce, QConv2DSparse, AveragePooling2DSparse
 
 
 def build_cnn(is_sparse, n_max_pixels=None):
+    iq_conf = QuantizerConfig(place='datalane', q_type='kif', i0=4, f0=8, overflow_mode='WRAP')
     with (
         QuantizerConfigScope(place='all', default_q_type='kbi', overflow_mode='SAT_SYM'),
         QuantizerConfigScope(place='datalane', default_q_type='kif', overflow_mode='WRAP'),
-        LayerConfigScope(enable_ebops=False, enable_iq=False),
+        LayerConfigScope(enable_ebops=True, enable_iq=True, beta0=1e-5),
     ):
         x_in = keras.Input(shape=(32, 32, 1), name='x_in')
         if is_sparse:
@@ -18,27 +20,27 @@ def build_cnn(is_sparse, n_max_pixels=None):
             x = x_in
 
         if is_sparse:
-            x = QConv2DSparse(filters=1, kernel_size=7, name='conv1', padding='same', strides=1)([x, keep_mask])
-            x = ReLU(name='relu1')(x)
+            x = QConv2DSparse(filters=1, kernel_size=7, name='conv1', padding='same', strides=1,
+                              activation='relu', iq_conf=iq_conf)([x, keep_mask])
             x, keep_mask = AveragePooling2DSparse(4, name='pool1')([x, keep_mask])
 
-            x = QConv2DSparse(filters=3, kernel_size=5, name='conv2', padding='same', strides=1)([x, keep_mask])
-            x = ReLU(name='relu2')(x)
+            x = QConv2DSparse(filters=3, kernel_size=5, name='conv2', padding='same', strides=1,
+                              activation='relu', iq_conf=iq_conf)([x, keep_mask])
             x, keep_mask = AveragePooling2DSparse(2, name='pool2')([x, keep_mask])
         else:
             x = QConv2D(filters=1, kernel_size=7, name='conv1', padding='same', strides=1,
-                        activation='relu')(x)
+                        activation='relu', iq_conf=iq_conf)(x)
             x = AveragePooling2D(4, name='pool1')(x)
 
             x = QConv2D(filters=3, kernel_size=5, name='conv2', padding='same', strides=1,
-                        activation='relu')(x)
+                        activation='relu', iq_conf=iq_conf)(x)
             x = AveragePooling2D(2, name='pool2')(x)
 
         x = Flatten(name='flatten')(x)
 
-        x = QDense(36, name='dense1', activation='relu')(x)
+        x = QDense(36, name='dense1', activation='relu', iq_conf=iq_conf)(x)
 
-        x = QDense(10, name='dense2')(x)
+        x = QDense(10, name='dense2', iq_conf=iq_conf)(x)
         x = Activation('softmax', name='softmax')(x)
 
     return keras.Model(x_in, x)