Merge branch 'main' into oneapi_backend/experiment

Author: jmitrevs

CITATION.cff

@@ -4,7 +4,8 @@ type: software
 authors:
 - given-names: "FastML Team"
 title: "hls4ml"
-version: "v1.0.0"
+version: "v1.1.0"
+date-released: "2025-03-17"
 doi: 10.5281/zenodo.1201549
 repository-code: "https://github.com/fastmachinelearning/hls4ml"
 url: "https://fastmachinelearning.org/hls4ml"

README.md

@@ -73,9 +73,9 @@ If you use this software in a publication, please cite the software
 @software{fastml_hls4ml,
   author       = {{FastML Team}},
   title        = {fastmachinelearning/hls4ml},
-  year         = 2024,
+  year         = 2025,
   publisher    = {Zenodo},
-  version      = {v1.0.0},
+  version      = {v1.1.0},
   doi          = {10.5281/zenodo.1201549},
   url          = {https://github.com/fastmachinelearning/hls4ml}
 }

docs/advanced/extension.rst

@@ -18,6 +18,9 @@ To implement a custom layer in ``hls4ml`` with the extension API, the required c
 * Function config template
 * Registration of layer, source code, and templates
 
+.. note::
+    currently, then extension API supports keras models. Support for pytorch models is in development.
+
 Complete example
 ================
 

docs/intro/setup.rst

@@ -20,14 +20,8 @@ If you want to use our :doc:`profiling <../advanced/profiling>` toolbox, you mig
 
    pip install hls4ml[profiling]
 
-``hls4ml`` is also available as a ``conda`` package in the ``conda-forge`` repository. To install, run:
-
 .. warning::
-   Version of hls4ml available on ``conda-forge`` is outdated, we recommend installing with ``pip`` to get the latest version.
-
-.. code-block::
-
-   conda install -c conda-forge hls4ml
+   Previously, versions of hls4ml were made available on ``conda-forge``. These are outdated and should NOT be used. Installing with ``pip`` is currently the only supported method.
 
 Development version
 -------------------

docs/intro/status.rst

@@ -89,14 +89,15 @@ A summary of the on-going status of the ``hls4ml`` tool is in the table below.
 
 Other feature notes:
 
-* ``hls4ml`` is tested on Linux, and supports
+* ``hls4ml`` is tested on the following platforms. Newer versions might work just fine, but try at your own risk.
    * Vivado HLS versions 2018.2 to 2020.1
-   * Intel HLS versions 20.1 to 21.4
-   * Vitis HLS versions 2022.2 to 2024.1
+   * Intel HLS versions 20.1 to 21.4, versions \> 21.4 have not been tested.
+   * Vitis HLS versions 2022.2 to 2024.1. Versions \<= 2022.1 are known not to work.
    * Catapult HLS versions 2024.1_1 to 2024.2
    * oneAPI versions 2024.1 to 2025.0
 
-* Windows and macOS are not supported
+* ``hls4ml`` supports Linux and requires python \>=3.10. hlsml does not require a specific Linux distribution version and we recommended to follow the requirements of the HLS tool you are using.
+* Windows and macOS are not supported. Setting up ``hls4ml`` on these platforms, for example using the Windows Subsystem for Linux (WSL) should be possible, but we do not provide support for such use cases.
 * BDT support has moved to the `Conifer <https://github.com/thesps/conifer>`__ package
 
 Example Models

hls4ml/model/graph.py

@@ -542,14 +542,14 @@ def remove_node(self, node, rewire=True):
         if len(inputs) > 1 or len(outputs) > 1:
             raise Exception('Cannot delete a node with multiple inputs/outputs')
 
-        if len(inputs) == 1:
+        if len(outputs) == 1 and len(inputs) == 1:
+
             # Connect inputs -> $outputs
-            if node.name in self.outputs:
+            if node.outputs[0] in self.outputs:
                 msg = f'Remove leaf node {node.name} will connect its input node {inputs[0]} to output, but it already is.'
                 assert inputs[0] not in self.outputs, msg
-                self.outputs = [inputs[0] if name == node.name else name for name in self.outputs]
+                self.outputs = [inputs[0] if name == node.outputs[0] else name for name in self.outputs]
 
-        if len(outputs) == 1 and len(inputs) == 1:
             inp_var = node.get_input_variable()
             out_var = node.get_output_variable()
 
@@ -565,9 +565,6 @@ def remove_node(self, node, rewire=True):
                     if outputs[0] == nxt_inp:
                         next_node.inputs[i] = inputs[0]
 
-        if node.outputs[0] in self.outputs:
-            prev_node = node.get_input_node(node.inputs[0])
-            self.outputs[self.outputs.index(node.outputs[0])] = prev_node.outputs[0]
         del self.output_vars[node.outputs[0]]
         del self.graph[node.name]
 

hls4ml/model/profiling.py

@@ -393,121 +393,12 @@ def activations_keras(model, X, fmt='longform', plot='boxplot'):
 
 
 def weights_torch(model, fmt='longform', plot='boxplot'):
+    from hls4ml.utils.profiling_utils import WeightsTorch
+
     wt = WeightsTorch(model, fmt, plot)
     return wt.get_weights()
 
 
-def _torch_batchnorm(layer):
-    weights = list(layer.parameters())
-    epsilon = layer.eps
-
-    gamma = weights[0]
-    beta = weights[1]
-    if layer.track_running_stats:
-        mean = layer.running_mean
-        var = layer.running_var
-    else:
-        mean = torch.tensor(np.ones(20))
-        var = torch.tensor(np.zeros(20))
-
-    scale = gamma / np.sqrt(var + epsilon)
-    bias = beta - gamma * mean / np.sqrt(var + epsilon)
-
-    return [scale, bias], ['s', 'b']
-
-
-def _torch_layer(layer):
-    return list(layer.parameters()), ['w', 'b']
-
-
-def _torch_rnn(layer):
-    return list(layer.parameters()), ['w_ih_l0', 'w_hh_l0', 'b_ih_l0', 'b_hh_l0']
-
-
-torch_process_layer_map = defaultdict(
-    lambda: _torch_layer,
-    {
-        'BatchNorm1d': _torch_batchnorm,
-        'BatchNorm2d': _torch_batchnorm,
-        'RNN': _torch_rnn,
-        'LSTM': _torch_rnn,
-        'GRU': _torch_rnn,
-    },
-)
-
-
-class WeightsTorch:
-    def __init__(self, model: torch.nn.Module, fmt: str = 'longform', plot: str = 'boxplot') -> None:
-        self.model = model
-        self.fmt = fmt
-        self.plot = plot
-        self.registered_layers = list()
-        self._find_layers(self.model, self.model.__class__.__name__)
-
-    def _find_layers(self, model, module_name):
-        for name, module in model.named_children():
-            if isinstance(module, (torch.nn.Sequential, torch.nn.ModuleList)):
-                self._find_layers(module, module_name + "." + name)
-            elif isinstance(module, (torch.nn.Module)) and self._is_parameterized(module):
-                if len(list(module.named_children())) != 0:
-                    # custom nn.Module, continue search
-                    self._find_layers(module, module_name + "." + name)
-                else:
-                    self._register_layer(module_name + "." + name)
-
-    def _is_registered(self, name: str) -> bool:
-        return name in self.registered_layers
-
-    def _register_layer(self, name: str) -> None:
-        if self._is_registered(name) is False:
-            self.registered_layers.append(name)
-
-    def _is_parameterized(self, module: torch.nn.Module) -> bool:
-        return any(p.requires_grad for p in module.parameters())
-
-    def _get_weights(self) -> pandas.DataFrame | list[dict]:
-        if self.fmt == 'longform':
-            data = {'x': [], 'layer': [], 'weight': []}
-        elif self.fmt == 'summary':
-            data = []
-        for layer_name in self.registered_layers:
-            layer = self._get_layer(layer_name, self.model)
-            name = layer.__class__.__name__
-            weights, suffix = torch_process_layer_map[layer.__class__.__name__](layer)
-            for i, w in enumerate(weights):
-                label = f'{name}/{suffix[i]}'
-                w = weights[i].detach().numpy()
-                w = w.flatten()
-                w = abs(w[w != 0])
-                n = len(w)
-                if n == 0:
-                    print(f'Weights for {name} are only zeros, ignoring.')
-                    break
-                if self.fmt == 'longform':
-                    data['x'].extend(w.tolist())
-                    data['layer'].extend([name] * n)
-                    data['weight'].extend([label] * n)
-                elif self.fmt == 'summary':
-                    data.append(array_to_summary(w, fmt=self.plot))
-                    data[-1]['layer'] = name
-                    data[-1]['weight'] = label
-
-        if self.fmt == 'longform':
-            data = pandas.DataFrame(data)
-        return data
-
-    def get_weights(self) -> pandas.DataFrame | list[dict]:
-        return self._get_weights()
-
-    def get_layers(self) -> list[str]:
-        return self.registered_layers
-
-    def _get_layer(self, layer_name: str, module: torch.nn.Module) -> torch.nn.Module:
-        for name in layer_name.split('.')[1:]:
-            module = getattr(module, name)
-        return module
-
-
 def activations_torch(model, X, fmt='longform', plot='boxplot'):
     X = torch.Tensor(X)
     if fmt == 'longform':

hls4ml/utils/profiling_utils.py

@@ -0,0 +1,119 @@
+from collections import defaultdict
+
+import numpy as np
+import pandas
+import torch
+
+from hls4ml.model.profiling import array_to_summary
+
+
+def _torch_batchnorm(layer):
+    weights = list(layer.parameters())
+    epsilon = layer.eps
+
+    gamma = weights[0]
+    beta = weights[1]
+    if layer.track_running_stats:
+        mean = layer.running_mean
+        var = layer.running_var
+    else:
+        mean = torch.tensor(np.ones(20))
+        var = torch.tensor(np.zeros(20))
+
+    scale = gamma / np.sqrt(var + epsilon)
+    bias = beta - gamma * mean / np.sqrt(var + epsilon)
+
+    return [scale, bias], ['s', 'b']
+
+
+def _torch_layer(layer):
+    return list(layer.parameters()), ['w', 'b']
+
+
+def _torch_rnn(layer):
+    return list(layer.parameters()), ['w_ih_l0', 'w_hh_l0', 'b_ih_l0', 'b_hh_l0']
+
+
+torch_process_layer_map = defaultdict(
+    lambda: _torch_layer,
+    {
+        'BatchNorm1d': _torch_batchnorm,
+        'BatchNorm2d': _torch_batchnorm,
+        'RNN': _torch_rnn,
+        'LSTM': _torch_rnn,
+        'GRU': _torch_rnn,
+    },
+)
+
+
+class WeightsTorch:
+
+    def __init__(self, model: torch.nn.Module, fmt: str = 'longform', plot: str = 'boxplot') -> None:
+        self.model = model
+        self.fmt = fmt
+        self.plot = plot
+        self.registered_layers = list()
+        self._find_layers(self.model, self.model.__class__.__name__)
+
+    def _find_layers(self, model, module_name):
+        for name, module in model.named_children():
+            if isinstance(module, (torch.nn.Sequential, torch.nn.ModuleList)):
+                self._find_layers(module, module_name + "." + name)
+            elif isinstance(module, (torch.nn.Module)) and self._is_parameterized(module):
+                if len(list(module.named_children())) != 0:
+                    # custom nn.Module, continue search
+                    self._find_layers(module, module_name + "." + name)
+                else:
+                    self._register_layer(module_name + "." + name)
+
+    def _is_registered(self, name: str) -> bool:
+        return name in self.registered_layers
+
+    def _register_layer(self, name: str) -> None:
+        if self._is_registered(name) is False:
+            self.registered_layers.append(name)
+
+    def _is_parameterized(self, module: torch.nn.Module) -> bool:
+        return any(p.requires_grad for p in module.parameters())
+
+    def _get_weights(self) -> pandas.DataFrame | list[dict]:
+        if self.fmt == 'longform':
+            data = {'x': [], 'layer': [], 'weight': []}
+        elif self.fmt == 'summary':
+            data = []
+        for layer_name in self.registered_layers:
+            layer = self._get_layer(layer_name, self.model)
+            name = layer.__class__.__name__
+            weights, suffix = torch_process_layer_map[layer.__class__.__name__](layer)
+            for i, w in enumerate(weights):
+                label = f'{name}/{suffix[i]}'
+                w = weights[i].detach().numpy()
+                w = w.flatten()
+                w = abs(w[w != 0])
+                n = len(w)
+                if n == 0:
+                    print(f'Weights for {name} are only zeros, ignoring.')
+                    break
+                if self.fmt == 'longform':
+                    data['x'].extend(w.tolist())
+                    data['layer'].extend([name] * n)
+                    data['weight'].extend([label] * n)
+                elif self.fmt == 'summary':
+                    data.append(array_to_summary(w, fmt=self.plot))
+                    data[-1]['layer'] = name
+                    data[-1]['weight'] = label
+
+        if self.fmt == 'longform':
+            data = pandas.DataFrame(data)
+        return data
+
+    def get_weights(self) -> pandas.DataFrame | list[dict]:
+        return self._get_weights()
+
+    def get_layers(self) -> list[str]:
+        return self.registered_layers
+
+    def _get_layer(self, layer_name: str, module: torch.nn.Module) -> torch.nn.Module:
+        for name in layer_name.split('.')[1:]:
+            module = getattr(module, name)
+        return module

test/pytest/test_qonnx.py

@@ -402,10 +402,6 @@ def test_tiny_unet_model(tiny_unet_model, backend):
 @pytest.mark.parametrize('backend', ['Vitis'])
 @pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
 def test_simple_model(model_name, io_type, backend, request):
-    if model_name == 'conv2d_small_mp_keras_model' and io_type == 'io_stream':
-        # Not yet supported due to an issue with channels last conversion
-        # There is a qonnx PR.
-        pytest.skip()
     model = request.getfixturevalue(model_name)
     ishape = tuple(model.get_tensor_shape(model.graph.input[0].name))
     X = np.random.uniform(low=0, high=1, size=np.prod(ishape)).reshape(ishape)