Merge with main (#52)

* Add quantized sigmoid, fix quantized tanh for QKeras (#569)

* snapshot of beginnings

* make version that works for Vivado, error for Quartus

* Change order of precision from quantizer

* add hard sigmoid and tanh

* fix setting of slope and shift type

* revert config parsing--seems a little strange but works

* fix hard_sigmoid and hard_tanh for streaming

* update pytest for quantized tanh and sigmoid

* remove inadvertently included matoplotlib

* add special case when W == min_width.

* fix merge of main

* Go back to having AP_TRN and AP_WRP as defaults

* handle case when use_real_tanh is not defined

* make the activations use AP_RND_CONV (and AP_SAT) by default

* remove use of use_real_tanh in test since not always supported

* fix incorrect default types for Keras (not QKeras) hard_sigmoid

* Mostly fix up things for Quartus

* get rid of intermediate cast

* fix an i++ compilation issue

* Quartus seems to not like ac_fixed<1,0,false>, so make 2 bits.

* fix activation quantizer

* make sat, round defeult activation parameters, don't need to set again

* Make the slope and shift not be configurable for HardActivation

* some pre-commit fixes

* pre-commint //hls to // hls fixes

* update CI version

* fixes for parsing errors from pre-commits

* remove qactivation from list of activation_layers

* print_vivado_report function for nicer reports (#730)

* print_vivado_report function for fancier reports

* Fancy reports (#51)

* fix uram divide by 0

* add test

* fix parsing of vsynth in 2020.1; add test

* Update test_report.py

* exclude pregenerated reports

---------

Co-authored-by: Javier Duarte <[email protected]>

---------

Co-authored-by: Jovan Mitrevski <[email protected]>
Co-authored-by: Vladimir <[email protected]>

Author: 3 people

.pre-commit-config.yaml

@@ -1,4 +1,4 @@
-exclude: ^hls4ml\/templates\/(vivado|quartus)\/(ap_types|ac_types)\/
+exclude: (^hls4ml\/templates\/(vivado|quartus)\/(ap_types|ac_types)\/|^test/pytest/test_report/)
 
 repos:
 - repo: https://github.com/psf/black

hls4ml/backends/quartus/passes/core_templates.py

@@ -1,7 +1,6 @@
-
 from hls4ml.backends.backend import get_backend
-from hls4ml.model.layers import Activation, BatchNormalization, Dense, PReLU, ParametrizedActivation, Softmax
-from hls4ml.backends.template import LayerConfigTemplate, FunctionCallTemplate
+from hls4ml.backends.template import FunctionCallTemplate, LayerConfigTemplate
+from hls4ml.model.layers import Activation, BatchNormalization, Dense, HardActivation, ParametrizedActivation, PReLU, Softmax
 
 # Dense templates
 
@@ -38,24 +37,28 @@
 
 dense_include_list = ['nnet_utils/nnet_dense.h', 'nnet_utils/nnet_dense_compressed.h', 'nnet_utils/nnet_dense_stream.h']
 
+
 class DenseConfigTemplate(LayerConfigTemplate):
     def __init__(self):
         super().__init__(Dense)
         self.template = dense_config_template
-    
+
     def format(self, node):
         params = self._default_config_params(node)
         params['nzeros'] = node.get_weights('weight').nzeros
         params['nonzeros'] = node.get_weights('weight').nonzeros
-        params['product_type'] = get_backend('quartus').product_type(node.get_input_variable().type.precision, node.get_weights('weight').type.precision)
+        params['product_type'] = get_backend('quartus').product_type(
+            node.get_input_variable().type.precision, node.get_weights('weight').type.precision
+        )
 
         return self.template.format(**params)
 
+
 class DenseFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(Dense, include_header=dense_include_list)
         self.template = dense_function_template
-    
+
     def format(self, node):
         params = self._default_function_params(node)
         params['w'] = node.get_weights('weight').name
@@ -82,23 +85,27 @@ def format(self, node):
 
 batchnorm_include_list = ['nnet_utils/nnet_batchnorm.h', 'nnet_utils/nnet_batchnorm_stream.h']
 
+
 class BatchNormalizationConfigTemplate(LayerConfigTemplate):
     def __init__(self):
         super().__init__(BatchNormalization)
         self.template = batchnorm_config_template
-    
+
     def format(self, node):
         params = self._default_config_params(node)
         params['n_in'] = node.get_input_variable().size_cpp()
-        params['product_type'] = get_backend('quartus').product_type(node.get_input_variable().type.precision, node.get_weights('scale').type.precision)
+        params['product_type'] = get_backend('quartus').product_type(
+            node.get_input_variable().type.precision, node.get_weights('scale').type.precision
+        )
 
         return self.template.format(**params)
 
+
 class BatchNormalizationFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(BatchNormalization, include_header=batchnorm_include_list)
         self.template = batchnorm_function_template
-    
+
     def format(self, node):
         params = self._default_function_params(node)
         params['scale'] = node.get_weights('scale').name
@@ -117,6 +124,16 @@ def format(self, node):
     typedef {table_t.name} table_t;
 }};\n"""
 
+hard_activ_config_template = """struct {type}_config{index} {{
+    static const unsigned n_in = {n_in};
+    static const {slope_t.name} slope;
+    static const {shift_t.name} shift;
+    static const unsigned io_type = nnet::{iotype};
+    static const unsigned reuse_factor = {reuse};
+}};
+const {slope_t.name} {type}_config{index}::slope = {slope};
+const {shift_t.name} {type}_config{index}::shift = {shift};\n"""
+
 softmax_config_template = """struct {type}_config{index} : nnet::activ_config {{
     static const unsigned n_in = {n_in};
     static const unsigned table_size = {table_size};
@@ -132,6 +149,7 @@ def format(self, node):
 
 activ_include_list = ['nnet_utils/nnet_activation.h', 'nnet_utils/nnet_activation_stream.h']
 
+
 class ActivationConfigTemplate(LayerConfigTemplate):
     def __init__(self):
         super().__init__((Activation, ParametrizedActivation, PReLU))
@@ -143,23 +161,38 @@ def format(self, node):
 
         return self.template.format(**params)
 
+
+class HardActivationConfigTemplate(LayerConfigTemplate):
+    def __init__(self):
+        super().__init__(HardActivation)
+        self.template = hard_activ_config_template
+
+    def format(self, node):
+        params = self._default_config_params(node)
+        params['type'] = node.get_attr('activation')
+
+        return self.template.format(**params)
+
+
 class SoftmaxConfigTemplate(ActivationConfigTemplate):
     def __init__(self):
-        super(ActivationConfigTemplate, self).__init__(Softmax) # Skip ActivationConfigTemplate's __init__
+        super(ActivationConfigTemplate, self).__init__(Softmax)  # Skip ActivationConfigTemplate's __init__
         self.template = softmax_config_template
 
+
 class ActivationFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
-        super().__init__((Activation, Softmax), include_header=activ_include_list)
+        super().__init__((Activation, HardActivation, Softmax), include_header=activ_include_list)
         self.template = activ_function_template
-    
+
     def format(self, node):
         params = self._default_function_params(node)
         params['activation'] = node.get_attr('activation').lower()
         params['config'] = '{}_config{}'.format(node.get_attr('activation'), node.index)
 
         return self.template.format(**params)
 
+
 class ParametrizedActivationFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(ParametrizedActivation, include_header=activ_include_list)
@@ -173,6 +206,7 @@ def format(self, node):
 
         return self.template.format(**params)
 
+
 class PReLUFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(PReLU, include_header=activ_include_list)

hls4ml/backends/vivado/passes/core_templates.py

@@ -1,7 +1,6 @@
-
 from hls4ml.backends.backend import get_backend
-from hls4ml.model.layers import Activation, BatchNormalization, Dense, Embedding, PReLU, ParametrizedActivation, Softmax
-from hls4ml.backends.template import LayerConfigTemplate, FunctionCallTemplate
+from hls4ml.backends.template import FunctionCallTemplate, LayerConfigTemplate
+from hls4ml.model.layers import Activation, BatchNormalization, Dense, HardActivation, ParametrizedActivation, PReLU, Softmax
 
 # Dense templates
 
@@ -27,24 +26,28 @@
 
 dense_include_list = ['nnet_utils/nnet_dense.h', 'nnet_utils/nnet_dense_compressed.h', 'nnet_utils/nnet_dense_stream.h']
 
+
 class DenseConfigTemplate(LayerConfigTemplate):
     def __init__(self):
         super().__init__(Dense)
         self.template = dense_config_template
-    
+
     def format(self, node):
         params = self._default_config_params(node)
         params['nzeros'] = node.get_weights('weight').nzeros
         params['nonzeros'] = node.get_weights('weight').nonzeros
-        params['product_type'] = get_backend('vivado').product_type(node.get_input_variable().type.precision, node.get_weights('weight').type.precision)
+        params['product_type'] = get_backend('vivado').product_type(
+            node.get_input_variable().type.precision, node.get_weights('weight').type.precision
+        )
 
         return self.template.format(**params)
 
+
 class DenseFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(Dense, include_header=dense_include_list)
         self.template = dense_function_template
-    
+
     def format(self, node):
         params = self._default_function_params(node)
         params['w'] = node.get_weights('weight').name
@@ -73,23 +76,27 @@ def format(self, node):
 
 batchnorm_include_list = ['nnet_utils/nnet_batchnorm.h', 'nnet_utils/nnet_batchnorm_stream.h']
 
+
 class BatchNormalizationConfigTemplate(LayerConfigTemplate):
     def __init__(self):
         super().__init__(BatchNormalization)
         self.template = batchnorm_config_template
-    
+
     def format(self, node):
         params = self._default_config_params(node)
         params['n_in'] = node.get_input_variable().size_cpp()
-        params['product_type'] = get_backend('vivado').product_type(node.get_input_variable().type.precision, node.get_weights('scale').type.precision)
+        params['product_type'] = get_backend('vivado').product_type(
+            node.get_input_variable().type.precision, node.get_weights('scale').type.precision
+        )
 
         return self.template.format(**params)
 
+
 class BatchNormalizationFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(BatchNormalization, include_header=batchnorm_include_list)
         self.template = batchnorm_function_template
-    
+
     def format(self, node):
         params = self._default_function_params(node)
         params['scale'] = node.get_weights('scale').name
@@ -108,6 +115,16 @@ def format(self, node):
     typedef {table_t.name} table_t;
 }};\n"""
 
+hard_activ_config_template = """struct {type}_config{index} {{
+    static const unsigned n_in = {n_in};
+    static const {slope_t.name} slope;
+    static const {shift_t.name} shift;
+    static const unsigned io_type = nnet::{iotype};
+    static const unsigned reuse_factor = {reuse};
+}};
+const {slope_t.name} {type}_config{index}::slope = {slope};
+const {shift_t.name} {type}_config{index}::shift = {shift};\n"""
+
 softmax_config_template = """struct {type}_config{index} : nnet::activ_config {{
     static const unsigned n_in = {n_in};
     static const unsigned table_size = {table_size};
@@ -124,6 +141,7 @@ def format(self, node):
 
 activ_include_list = ['nnet_utils/nnet_activation.h', 'nnet_utils/nnet_activation_stream.h']
 
+
 class ActivationConfigTemplate(LayerConfigTemplate):
     def __init__(self):
         super().__init__((Activation, ParametrizedActivation, PReLU))
@@ -135,23 +153,38 @@ def format(self, node):
 
         return self.template.format(**params)
 
+
+class HardActivationConfigTemplate(LayerConfigTemplate):
+    def __init__(self):
+        super().__init__(HardActivation)
+        self.template = hard_activ_config_template
+
+    def format(self, node):
+        params = self._default_config_params(node)
+        params['type'] = node.get_attr('activation')
+
+        return self.template.format(**params)
+
+
 class SoftmaxConfigTemplate(ActivationConfigTemplate):
     def __init__(self):
-        super(ActivationConfigTemplate, self).__init__(Softmax) # Skip ActivationConfigTemplate's __init__
+        super(ActivationConfigTemplate, self).__init__(Softmax)  # Skip ActivationConfigTemplate's __init__
         self.template = softmax_config_template
 
+
 class ActivationFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
-        super().__init__((Activation, Softmax), include_header=activ_include_list)
+        super().__init__((Activation, HardActivation, Softmax), include_header=activ_include_list)
         self.template = activ_function_template
-    
+
     def format(self, node):
         params = self._default_function_params(node)
         params['activation'] = node.get_attr('activation').lower()
         params['config'] = '{}_config{}'.format(node.get_attr('activation'), node.index)
 
         return self.template.format(**params)
 
+
 class ParametrizedActivationFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(ParametrizedActivation, include_header=activ_include_list)
@@ -165,6 +198,7 @@ def format(self, node):
 
         return self.template.format(**params)
 
+
 class PReLUFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
         super().__init__(PReLU, include_header=activ_include_list)

hls4ml/converters/keras/core.py

@@ -105,6 +105,8 @@ def parse_activation_layer(keras_layer, input_names, input_shapes, data_reader):
 
     if layer['class_name'] == 'Activation' and layer['activation'] == 'softmax':
         layer['class_name'] = 'Softmax'
+    if layer['class_name'] == 'Activation' and layer['activation'] == 'hard_sigmoid':
+        layer['class_name'] = 'HardActivation'
     if layer['class_name'] == 'Softmax':
         layer['axis'] = keras_layer['config'].get('axis', -1)
 

hls4ml/converters/keras/qkeras_layers.py

@@ -4,6 +4,7 @@
 from hls4ml.converters.keras.core import parse_batchnorm_layer, parse_dense_layer
 from hls4ml.converters.keras.qkeras import get_quantizer_from_config
 from hls4ml.converters.keras_to_hls import keras_handler, parse_default_keras_layer
+from hls4ml.model.types import FixedPrecisionType
 
 
 @keras_handler('QDense')
@@ -46,6 +47,7 @@ def parse_qactivation_layer(keras_layer, input_names, input_shapes, data_reader)
         'quantized_tanh',
         'binary_tanh',
         'ternary_tanh',
+        'quantized_sigmoid',
         'quantized_bits',
         'binary',
         'ternary',
@@ -79,16 +81,32 @@ def parse_qactivation_layer(keras_layer, input_names, input_shapes, data_reader)
     if activation_config['class_name'] not in supported_activations:
         raise Exception('Unsupported QKeras activation: {}'.format(activation_config['class_name']))
 
+    if activation_config['class_name'] == 'quantized_bits':
+        activation_config['class_name'] = 'linear'
+
     if activation_config['class_name'] == 'ternary_tanh':
         layer['class_name'] = 'TernaryTanh'
         layer['threshold'] = activation_config.get('config', {}).get('threshold', 0.33)
         if layer['threshold'] is None:
             layer['threshold'] = 0.33  # the default ternary tanh threshold for QKeras
+        layer['activation'] = 'ternary_tanh'
+    elif (
+        activation_config['class_name'] == 'quantized_sigmoid'
+        and not activation_config['config'].get('use_real_sigmoid', False)
+    ) or (
+        activation_config['class_name'] == 'quantized_tanh' and not activation_config['config'].get('use_real_tanh', False)
+    ):
+        layer['class_name'] = 'HardActivation'
+        layer['slope'] = 0.5  # the default values in QKeras
+        layer['shift'] = 0.5
+        # Quartus seems to have trouble if the width is 1.
+        layer['slope_prec'] = FixedPrecisionType(width=2, integer=0, signed=False)
+        layer['shift_prec'] = FixedPrecisionType(width=2, integer=0, signed=False)
+        layer['activation'] = activation_config['class_name'].replace('quantized_', 'hard_')
     else:
         layer['class_name'] = 'Activation'
-    if activation_config['class_name'] == 'quantized_bits':
-        activation_config['class_name'] = 'linear'
-    layer['activation'] = activation_config['class_name'].replace('quantized_', '')
+        layer['activation'] = activation_config['class_name'].replace('quantized_', '')
+
     layer['activation_quantizer'] = activation_config
     return layer, [shape for shape in input_shapes[0]]
 

hls4ml/converters/keras_to_hls.py

@@ -257,7 +257,16 @@ def parse_keras_model(model_arch, reader):
     # Define layers to skip for conversion to HLS
     skip_layers = ['Dropout']
     # Activation layers
-    activation_layers = ['Activation', 'LeakyReLU', 'ThresholdedReLU', 'ELU', 'PReLU', 'Softmax', 'TernaryTanh']
+    activation_layers = [
+        'Activation',
+        'LeakyReLU',
+        'ThresholdedReLU',
+        'ELU',
+        'PReLU',
+        'Softmax',
+        'TernaryTanh',
+        'HardActivation',
+    ]
     # Recurrent layers
     recurrent_layers = ['SimpleRNN', 'LSTM', 'GRU']
     # All supported layers