sparsepixels 0.1.1__tar.gz → 0.2.0__tar.gz

{sparsepixels-0.1.1/sparsepixels.egg-info → sparsepixels-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sparsepixels
-Version: 0.1.1
+Version: 0.2.0
 Summary: Efficient convolution for sparse data on FPGAs
 Home-page: https://github.com/hftsoi/sparse-pixels
 Author: Ho Fung Tsoi
@@ -8,13 +8,12 @@ Author-email: ho.fung.tsoi@cern.ch
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
-Requires-Python: <3.12,>=3.10
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tensorflow<2.15.0,>=2.14.0
-Requires-Dist: keras<2.15.0,>=2.14.0
-Requires-Dist: qkeras<0.10.0,>=0.9.0
-Requires-Dist: pyparsing<3.4.0,>=3.3.0
+Requires-Dist: tensorflow
+Requires-Dist: keras>=3.0
+Requires-Dist: HGQ2
 Dynamic: license-file
 
 <p align="center">
@@ -35,39 +34,65 @@ Dynamic: license-file
 [![arXiv](https://img.shields.io/badge/arXiv-2512.06208-b31b1b.svg?style=flat-square)](https://arxiv.org/abs/2512.06208)
 [![PyPI - Version](https://img.shields.io/pypi/v/sparsepixels?color=orange&style=flat-square)](https://pypi.org/project/sparsepixels)
 
-> **Note:** we are actively working on making this usable soon, before integrating into hls4ml (first qkeras with keras2, and then HGQ with keras3), we are also working on a major upgrade with partial paralleliztion and streaming for sparse layers in HLS. stay tuned!!
+> **Note:** We are actively working on hls4ml integration to auto-convert sparse models to HLS, along with a major upgrade with partial parallelization and streaming for sparse layers in HLS. Stay tuned!
 
 ## Installation
-With Python 3.10 or 3.11 (for now):
+
+With Python >= 3.10:
+
 ```
 pip install sparsepixels
 ```
 
 ## Getting Started
-On the model training in Python, import sparse layers:
-```
-from sparsepixels.layers import *
-```
-Sparse input reduction:
-```
-x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), name='x_in')
-x, keep_mask = InputReduce(n_max_pixels=n_max_pixels, threshold=threshold, name='input_reduce')(x_in)
-```
-Sparse convolution:
-```
-x = QConv2DSparse(filters=1, kernel_size=7, use_bias=True, name='conv1', padding='same', strides=1,
-                          kernel_quantizer=quantizer, bias_quantizer=quantizer)([x, keep_mask])
-```
-Sparse pooling:
+
+Import sparse layers and quantization library (HGQ2):
+
+```python
+import keras
+from keras.layers import Flatten, Activation, ReLU
+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
 ```
-x, keep_mask = AveragePooling2DSparse(4, name='pool1')([x, keep_mask])
+
+Build an example sparse CNN within HGQ2 quantization scopes:
+
+```python
+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),
+):
+    x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), 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,
+                      bq_conf=QuantizerConfig('default', 'bias'))([x, keep_mask])
+    x = ReLU(name='relu1')(x)
+
+    # 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 = 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.
 
 ## Documentation
 
 ## Citation
+
 If you find this useful in your research, please consider citing:
+
 ```
 @article{Tsoi:2025nvg,
     author = "Tsoi, Ho Fung and Rankin, Dylan and Loncar, Vladimir and Harris, Philip",
@@ -79,3 +104,4 @@ If you find this useful in your research, please consider citing:
     year = "2025"
 }
 ```
+

sparsepixels-0.2.0/README.md

@@ -0,0 +1,89 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/logo.png" width="300" />
+</p>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/sparsepixels.png" width="900"/>
+</p>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/cnn_standard.gif" width="400" />
+  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/cnn_sparse.gif" width="400" />
+</p>
+
+# SparsePixels: Efficient convolution for sparse data on FPGAs
+
+[![arXiv](https://img.shields.io/badge/arXiv-2512.06208-b31b1b.svg?style=flat-square)](https://arxiv.org/abs/2512.06208)
+[![PyPI - Version](https://img.shields.io/pypi/v/sparsepixels?color=orange&style=flat-square)](https://pypi.org/project/sparsepixels)
+
+> **Note:** We are actively working on hls4ml integration to auto-convert sparse models to HLS, along with a major upgrade with partial parallelization and streaming for sparse layers in HLS. Stay tuned!
+
+## Installation
+
+With Python >= 3.10:
+
+```
+pip install sparsepixels
+```
+
+## Getting Started
+
+Import sparse layers and quantization library (HGQ2):
+
+```python
+import keras
+from keras.layers import Flatten, Activation, ReLU
+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:
+
+```python
+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),
+):
+    x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), 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,
+                      bq_conf=QuantizerConfig('default', 'bias'))([x, keep_mask])
+    x = ReLU(name='relu1')(x)
+
+    # 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 = 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.
+
+## Documentation
+
+## Citation
+
+If you find this useful in your research, please consider citing:
+
+```
+@article{Tsoi:2025nvg,
+    author = "Tsoi, Ho Fung and Rankin, Dylan and Loncar, Vladimir and Harris, Philip",
+    title = "{SparsePixels: Efficient Convolution for Sparse Data on FPGAs}",
+    eprint = "2512.06208",
+    archivePrefix = "arXiv",
+    primaryClass = "cs.AR",
+    month = "12",
+    year = "2025"
+}
+```
+

{sparsepixels-0.1.1 → sparsepixels-0.2.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = sparsepixels
-version = 0.1.1
+version = 0.2.0
 description = Efficient convolution for sparse data on FPGAs
 author = Ho Fung Tsoi
 author_email = ho.fung.tsoi@cern.ch
@@ -15,12 +15,11 @@ classifiers =
 
 [options]
 packages = find_namespace:
-python_requires = >=3.10,<3.12
+python_requires = >=3.10
 install_requires = 
-	tensorflow>=2.14.0,<2.15.0
-	keras>=2.14.0,<2.15.0
-	qkeras>=0.9.0,<0.10.0
-	pyparsing>=3.3.0,<3.4.0
+	tensorflow
+	keras>=3.0
+	HGQ2
 include_package_data = True
 
 [options.package_data]

{sparsepixels-0.1.1 → sparsepixels-0.2.0}/sparsepixels/layers.py

@@ -1,93 +1,97 @@
-import tensorflow as tf
-from qkeras import QConv2D, quantizers
-from tensorflow.keras.layers import AveragePooling2D, MaxPooling2D
+import keras
+from keras import ops
+from keras.layers import AveragePooling2D, MaxPooling2D
+from hgq.layers import QConv2D
+from hgq.quantizer import Quantizer
+from hgq.quantizer.config import QuantizerConfig
 
-class InputReduce(tf.keras.layers.Layer):
+
+class InputReduce(keras.layers.Layer):
     def __init__(self, n_max_pixels, threshold, **kwargs):
-        super(InputReduce, self).__init__(**kwargs)
+        super().__init__(**kwargs)
         self.n_max_pixels = n_max_pixels
         self.threshold = threshold
 
     def call(self, inputs):
-        batch_size = tf.shape(inputs)[0]
-        h = tf.shape(inputs)[1]
-        w = tf.shape(inputs)[2]
-
-        '''
-        if self.threshold is not None:
-            cond = inputs > self.threshold
-        else:
-            cond = inputs != 0
-        active_flag = tf.cast(tf.reduce_any(cond, axis=-1), tf.int32)
-        '''
+        batch_size = ops.shape(inputs)[0]
+        h = ops.shape(inputs)[1]
+        w = ops.shape(inputs)[2]
 
         # to be consistent with hls, check only the first input channel
         if self.threshold is not None:
-            active_flag = tf.cast(inputs[..., 0] > self.threshold, tf.int32)
+            active_flag = ops.cast(inputs[..., 0] > self.threshold, "int32")
         else:
-            active_flag = tf.cast(inputs[..., 0] != 0, tf.int32)
+            active_flag = ops.cast(inputs[..., 0] != 0, "int32")
 
-        active_flag_flat = tf.reshape(active_flag, [batch_size, h * w])
-        active_count = tf.cumsum(active_flag_flat, axis=1)
+        active_flag_flat = ops.reshape(active_flag, [batch_size, h * w])
+        active_count = ops.cumsum(active_flag_flat, axis=1)
 
-        keep_mask_flat = tf.cast(tf.logical_and(active_flag_flat == 1, active_count <= self.n_max_pixels), inputs.dtype)
-        keep_mask = tf.reshape(keep_mask_flat, [batch_size, h, w, 1])
+        keep_mask_flat = ops.cast(
+            ops.logical_and(active_flag_flat == 1, active_count <= self.n_max_pixels),
+            inputs.dtype,
+        )
+        keep_mask = ops.reshape(keep_mask_flat, [batch_size, h, w, 1])
 
         inputs_reduced = inputs * keep_mask
         return inputs_reduced, keep_mask
 
     def get_config(self):
-        config = super(InputReduce, self).get_config()
+        config = super().get_config()
         config.update({
             "n_max_pixels": self.n_max_pixels,
-            "threshold": self.threshold
+            "threshold": self.threshold,
         })
         return config
-    
 
-class RemoveDilatedPixels(tf.keras.layers.Layer):
+
+class RemoveDilatedPixels(keras.layers.Layer):
     def __init__(self, **kwargs):
-        super(RemoveDilatedPixels, self).__init__(**kwargs)
+        super().__init__(**kwargs)
 
     def call(self, inputs):
         x, mask = inputs
-        mask = tf.cast(mask, x.dtype)
-        removed = x * mask
-        return removed
+        mask = ops.cast(mask, x.dtype)
+        return x * mask
 
     def get_config(self):
-        config = super(RemoveDilatedPixels, self).get_config()
-        return config
+        return super().get_config()
 
 
-class QConv2DSparse(tf.keras.layers.Layer):
+class QConv2DSparse(keras.layers.Layer):
     def __init__(self, *conv_args, **conv_kwargs):
         super().__init__(name=conv_kwargs.get("name", None))
-        self._bias_quant_cfg = conv_kwargs.pop("bias_quantizer", None)
-        self._bias_quantizer = (quantizers.get_quantizer(self._bias_quant_cfg) if self._bias_quant_cfg is not None else None)
+        self._bq_conf = conv_kwargs.pop("bq_conf", None)
 
         conv_kwargs["use_bias"] = False
+        conv_kwargs.setdefault("enable_iq", False)
         self.conv = QConv2D(*conv_args, **conv_kwargs)
-        self.bias = self.add_weight(
-            name = "bias",
-            shape = (self.conv.filters,),
-            initializer = "zeros",
-            trainable = True,
-            dtype = self.conv.dtype,
-        )
         self.masker = RemoveDilatedPixels()
 
+    def build(self, input_shape):
+        self.sparse_bias = self.add_weight(
+            name="sparse_bias",
+            shape=(self.conv.filters,),
+            initializer="zeros",
+            trainable=True,
+        )
+        if self._bq_conf is not None:
+            self._bq = Quantizer(self._bq_conf, name=f"{self.name}_bq")
+            self._bq.build((self.conv.filters,))
+        else:
+            self._bq = None
+        super().build(input_shape)
+
     def call(self, inputs, **kwargs):
         x, keep_mask = inputs
         x = self.masker((x, keep_mask))
         y = self.conv(x, **kwargs)
 
-        b = self.bias
-        if self._bias_quantizer is not None:
-            b = self._bias_quantizer(b)
-        b = tf.reshape(b, shape=(1, 1, 1, -1))
+        b = self.sparse_bias
+        if self._bq is not None:
+            b = self._bq(b)
+        b = ops.reshape(b, (1, 1, 1, -1))
 
-        non_zero = tf.cast(tf.not_equal(y, 0), y.dtype)
+        non_zero = ops.cast(y != 0, y.dtype)
         y = y + b * non_zero
 
         y = self.masker((y, keep_mask))
@@ -96,18 +100,17 @@ class QConv2DSparse(tf.keras.layers.Layer):
     def get_config(self):
         cfg = super().get_config()
         cfg["conv_config"] = self.conv.get_config()
-        cfg["bias_quantizer"] = self._bias_quant_cfg
+        cfg["bq_conf"] = self._bq_conf
         return cfg
 
     @classmethod
     def from_config(cls, config):
         conv_cfg = config.pop("conv_config")
-        bias_quant_cfg = config.pop("bias_quantizer", None)
-        layer = cls(**conv_cfg, bias_quantizer=bias_quant_cfg)
-        return layer
+        bq_conf = config.pop("bq_conf", None)
+        return cls(**conv_cfg, bq_conf=bq_conf)
 
 
-class AveragePooling2DSparse(tf.keras.layers.Layer):
+class AveragePooling2DSparse(keras.layers.Layer):
     def __init__(self, *pool_args, **pool_kwargs):
         super().__init__(name=pool_kwargs.get("name", None))
         self.avg_pool = AveragePooling2D(*pool_args, **pool_kwargs)
@@ -128,9 +131,9 @@ class AveragePooling2DSparse(tf.keras.layers.Layer):
     def from_config(cls, config):
         pool_cfg = config.pop("pool_config")
         return cls(**pool_cfg)
-    
 
-class MaxPooling2DSparse(tf.keras.layers.Layer):
+
+class MaxPooling2DSparse(keras.layers.Layer):
     def __init__(self, *pool_args, **pool_kwargs):
         super().__init__(name=pool_kwargs.get("name", None))
         self.max_pool = MaxPooling2D(*pool_args, **pool_kwargs)
@@ -150,4 +153,3 @@ class MaxPooling2DSparse(tf.keras.layers.Layer):
     def from_config(cls, config):
         pool_cfg = config.pop("pool_config")
         return cls(**pool_cfg)
-

{sparsepixels-0.1.1 → sparsepixels-0.2.0/sparsepixels.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sparsepixels
-Version: 0.1.1
+Version: 0.2.0
 Summary: Efficient convolution for sparse data on FPGAs
 Home-page: https://github.com/hftsoi/sparse-pixels
 Author: Ho Fung Tsoi
@@ -8,13 +8,12 @@ Author-email: ho.fung.tsoi@cern.ch
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
-Requires-Python: <3.12,>=3.10
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tensorflow<2.15.0,>=2.14.0
-Requires-Dist: keras<2.15.0,>=2.14.0
-Requires-Dist: qkeras<0.10.0,>=0.9.0
-Requires-Dist: pyparsing<3.4.0,>=3.3.0
+Requires-Dist: tensorflow
+Requires-Dist: keras>=3.0
+Requires-Dist: HGQ2
 Dynamic: license-file
 
 <p align="center">
@@ -35,39 +34,65 @@ Dynamic: license-file
 [![arXiv](https://img.shields.io/badge/arXiv-2512.06208-b31b1b.svg?style=flat-square)](https://arxiv.org/abs/2512.06208)
 [![PyPI - Version](https://img.shields.io/pypi/v/sparsepixels?color=orange&style=flat-square)](https://pypi.org/project/sparsepixels)
 
-> **Note:** we are actively working on making this usable soon, before integrating into hls4ml (first qkeras with keras2, and then HGQ with keras3), we are also working on a major upgrade with partial paralleliztion and streaming for sparse layers in HLS. stay tuned!!
+> **Note:** We are actively working on hls4ml integration to auto-convert sparse models to HLS, along with a major upgrade with partial parallelization and streaming for sparse layers in HLS. Stay tuned!
 
 ## Installation
-With Python 3.10 or 3.11 (for now):
+
+With Python >= 3.10:
+
 ```
 pip install sparsepixels
 ```
 
 ## Getting Started
-On the model training in Python, import sparse layers:
-```
-from sparsepixels.layers import *
-```
-Sparse input reduction:
-```
-x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), name='x_in')
-x, keep_mask = InputReduce(n_max_pixels=n_max_pixels, threshold=threshold, name='input_reduce')(x_in)
-```
-Sparse convolution:
-```
-x = QConv2DSparse(filters=1, kernel_size=7, use_bias=True, name='conv1', padding='same', strides=1,
-                          kernel_quantizer=quantizer, bias_quantizer=quantizer)([x, keep_mask])
-```
-Sparse pooling:
+
+Import sparse layers and quantization library (HGQ2):
+
+```python
+import keras
+from keras.layers import Flatten, Activation, ReLU
+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
 ```
-x, keep_mask = AveragePooling2DSparse(4, name='pool1')([x, keep_mask])
+
+Build an example sparse CNN within HGQ2 quantization scopes:
+
+```python
+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),
+):
+    x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), 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,
+                      bq_conf=QuantizerConfig('default', 'bias'))([x, keep_mask])
+    x = ReLU(name='relu1')(x)
+
+    # 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 = 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.
 
 ## Documentation
 
 ## Citation
+
 If you find this useful in your research, please consider citing:
+
 ```
 @article{Tsoi:2025nvg,
     author = "Tsoi, Ho Fung and Rankin, Dylan and Loncar, Vladimir and Harris, Philip",
@@ -79,3 +104,4 @@ If you find this useful in your research, please consider citing:
     year = "2025"
 }
 ```
+

{sparsepixels-0.1.1 → sparsepixels-0.2.0}/sparsepixels.egg-info/SOURCES.txt

@@ -11,4 +11,6 @@ sparsepixels.egg-info/SOURCES.txt
 sparsepixels.egg-info/dependency_links.txt
 sparsepixels.egg-info/requires.txt
 sparsepixels.egg-info/top_level.txt
-sparsepixels/img/logo.png
+sparsepixels/img/logo.png
+tests/__init__.py
+tests/test_model.py

sparsepixels-0.2.0/sparsepixels.egg-info/requires.txt

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

{sparsepixels-0.1.1 → sparsepixels-0.2.0}/sparsepixels.egg-info/top_level.txt

@@ -1,9 +1,8 @@
-datasets
 dist
 docs
 hls_proj
 hls_templates
 notebook
-plots
 sparsepixels
+tests
 weights

sparsepixels-0.2.0/tests/test_model.py

@@ -0,0 +1,58 @@
+import keras
+from keras.layers import Flatten, Activation, AveragePooling2D, ReLU
+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):
+    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),
+    ):
+        x_in = keras.Input(shape=(32, 32, 1), name='x_in')
+        if is_sparse:
+            x, keep_mask = InputReduce(n_max_pixels=n_max_pixels, threshold=1, name='input_reduce')(x_in)
+        else:
+            x = x_in
+
+        if is_sparse:
+            x = QConv2DSparse(filters=1, kernel_size=7, name='conv1', padding='same', strides=1,
+                              bq_conf=QuantizerConfig('default', 'bias'))([x, keep_mask])
+            x = ReLU(name='relu1')(x)
+            x, keep_mask = AveragePooling2DSparse(4, name='pool1')([x, keep_mask])
+
+            x = QConv2DSparse(filters=3, kernel_size=5, name='conv2', padding='same', strides=1,
+                              bq_conf=QuantizerConfig('default', 'bias'))([x, keep_mask])
+            x = ReLU(name='relu2')(x)
+            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)
+            x = AveragePooling2D(4, name='pool1')(x)
+
+            x = QConv2D(filters=3, kernel_size=5, name='conv2', padding='same', strides=1,
+                        activation='relu')(x)
+            x = AveragePooling2D(2, name='pool2')(x)
+
+        x = Flatten(name='flatten')(x)
+
+        x = QDense(36, name='dense1', activation='relu')(x)
+
+        x = QDense(10, name='dense2')(x)
+        x = Activation('softmax', name='softmax')(x)
+
+    return keras.Model(x_in, x)
+
+
+def test_build_full_cnn():
+    cnn_full = build_cnn(is_sparse=False)
+    cnn_full.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss='categorical_crossentropy', metrics=['accuracy'])
+    cnn_full.summary()
+
+def test_build_sparse_cnn():
+    cnn_sparse = build_cnn(is_sparse=True, n_max_pixels=20)
+    cnn_sparse.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss='categorical_crossentropy', metrics=['accuracy'])
+    cnn_sparse.summary()

sparsepixels-0.1.1/README.md

@@ -1,62 +0,0 @@
-<p align="center">
-  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/logo.png" width="300" />
-</p>
-
-<p align="center">
-  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/sparsepixels.png" width="900"/>
-</p>
-
-<p align="center">
-  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/cnn_standard.gif" width="400" />
-  <img src="https://raw.githubusercontent.com/hftsoi/sparse-pixels/main/docs/figs/cnn_sparse.gif" width="400" />
-</p>
-
-# SparsePixels: Efficient convolution for sparse data on FPGAs
-
-[![arXiv](https://img.shields.io/badge/arXiv-2512.06208-b31b1b.svg?style=flat-square)](https://arxiv.org/abs/2512.06208)
-[![PyPI - Version](https://img.shields.io/pypi/v/sparsepixels?color=orange&style=flat-square)](https://pypi.org/project/sparsepixels)
-
-> **Note:** we are actively working on making this usable soon, before integrating into hls4ml (first qkeras with keras2, and then HGQ with keras3), we are also working on a major upgrade with partial paralleliztion and streaming for sparse layers in HLS. stay tuned!!
-
-## Installation
-With Python 3.10 or 3.11 (for now):
-```
-pip install sparsepixels
-```
-
-## Getting Started
-On the model training in Python, import sparse layers:
-```
-from sparsepixels.layers import *
-```
-Sparse input reduction:
-```
-x_in = keras.Input(shape=(x_train.shape[1], x_train.shape[2], x_train.shape[3]), name='x_in')
-x, keep_mask = InputReduce(n_max_pixels=n_max_pixels, threshold=threshold, name='input_reduce')(x_in)
-```
-Sparse convolution:
-```
-x = QConv2DSparse(filters=1, kernel_size=7, use_bias=True, name='conv1', padding='same', strides=1,
-                          kernel_quantizer=quantizer, bias_quantizer=quantizer)([x, keep_mask])
-```
-Sparse pooling:
-```
-x, keep_mask = AveragePooling2DSparse(4, name='pool1')([x, keep_mask])
-```
-We are working on hls4ml integration that auto parses the sparse layers into HLS.
-
-## Documentation
-
-## Citation
-If you find this useful in your research, please consider citing:
-```
-@article{Tsoi:2025nvg,
-    author = "Tsoi, Ho Fung and Rankin, Dylan and Loncar, Vladimir and Harris, Philip",
-    title = "{SparsePixels: Efficient Convolution for Sparse Data on FPGAs}",
-    eprint = "2512.06208",
-    archivePrefix = "arXiv",
-    primaryClass = "cs.AR",
-    month = "12",
-    year = "2025"
-}
-```

sparsepixels-0.1.1/sparsepixels.egg-info/requires.txt

@@ -1,4 +0,0 @@
-tensorflow<2.15.0,>=2.14.0
-keras<2.15.0,>=2.14.0
-qkeras<0.10.0,>=0.9.0
-pyparsing<3.4.0,>=3.3.0