Leaky Quantized ReLU fix

hls4ml/backends/vivado_accelerator/vivado_accelerator_config.py

@@ -75,9 +75,9 @@ def __init__(self, config, model_inputs, model_outputs):
         else:
             self.input_bitwidth = config.backend.convert_precision_string(inp_axi_t).width
 
-        if out_axi_t == 'float':
+        if str(out_axi_t) == 'float':
             self.output_bitwidth = 32
-        elif out_axi_t == 'double':
+        elif str(out_axi_t) == 'double':
             self.output_bitwidth = 64
         else:
             self.output_bitwidth = config.backend.convert_precision_string(out_axi_t).width

hls4ml/converters/keras/qkeras.py

@@ -117,7 +117,6 @@ def parse_qactivation_layer(keras_layer, input_names, input_shapes, data_reader)
     ]
 
     layer = parse_default_keras_layer(keras_layer, input_names)
-
     activation_config = keras_layer['config']['activation']
     quantizer_obj = get_quantizer(activation_config)
     activation_config = {}
@@ -166,6 +165,10 @@ def parse_qactivation_layer(keras_layer, input_names, input_shapes, data_reader)
         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_')
+    elif activation_config['class_name'] == 'quantized_relu' and activation_config['config']['negative_slope'] != 0:
+        layer['class_name'] = 'LeakyReLU'
+        layer['activation'] = activation_config['class_name'].replace('quantized_', 'leaky_')
+        layer['activ_param'] = activation_config['config']['negative_slope']
     else:
         layer['class_name'] = 'Activation'
         layer['activation'] = activation_config['class_name'].replace('quantized_', '')

hls4ml/converters/keras_to_hls.py

@@ -208,6 +208,7 @@ def parse_keras_model(model_arch, reader):
     ]
     # Recurrent layers
     recurrent_layers = ['SimpleRNN', 'LSTM', 'GRU']
+
     # All supported layers
     supported_layers = get_supported_keras_layers() + skip_layers
 
@@ -263,7 +264,6 @@ def parse_keras_model(model_arch, reader):
                 input_shapes = [output_shape]
 
         keras_class = keras_layer['class_name']
-
         if keras_class in skip_layers:
             if 'inbound_nodes' in keras_layer:
                 name = keras_layer['config']['name']
@@ -293,7 +293,11 @@ def parse_keras_model(model_arch, reader):
             )
         )
         layer_list.append(layer)
-        if 'activation' in layer and layer['class_name'] not in activation_layers + recurrent_layers:  # + qkeras_layers:
+        if (
+            'activation' in layer
+            and layer['class_name'] not in activation_layers + recurrent_layers
+            and layer['activation'] != "linear"
+        ):  # + qkeras_layers:
             act_layer = {}
             # Workaround for QKeras activations passed as an argument
             if isinstance(layer['activation'], dict):

hls4ml/model/profiling.py

@@ -589,8 +589,9 @@ def get_ymodel_keras(keras_model, X):
         name = layer.name
         if (
             hasattr(layer, "activation")
-            and layer.activation.__name__ != "linear"
+            and layer.activation is not None
             and not isinstance(layer, (keras.layers.Activation, qkeras.qlayers.QActivation))
+            and layer.activation.__name__ != "linear"
         ):
             tmp_activation = layer.activation
             layer.activation = None

hls4ml/utils/config.py

@@ -79,8 +79,11 @@ def _get_precision_from_quantizer(quantizer):
         rnd = "AP_RND_CONV"
         overflow = "AP_SAT"
         if quantizer['class_name'] in ('quantized_relu', 'quantized_relu_po2'):
-            signed = False
-            integer -= 1
+            if quantizer['config']['negative_slope'] != 0.0:
+                signed = True
+            else:
+                signed = False
+                integer -= 1
         elif quantizer['class_name'] == 'quantized_tanh':
             overflow = "AP_SAT_SYM" if quantizer['config']['symmetric'] else "AP_SAT"
             integer = 1

test/pytest/test_q_leaky_relu.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+from qkeras.qlayers import QActivation
+from qkeras.quantizers import quantized_relu
+from tensorflow.keras.models import Sequential
+
+import hls4ml
+
+test_root_path = Path(__file__).parent
+
+
+def randX(batch_size, N):
+    return np.random.rand(batch_size, N)
+
+
+@pytest.fixture(scope='module')
+def randX_1000_1():
+    return randX(1000, 1)
+
+
+@pytest.mark.parametrize(
+    'quantizer',
+    [
+        (quantized_relu(4, negative_slope=0.5)),
+        (quantized_relu(4, 2, negative_slope=0.5)),
+        (quantized_relu(8, negative_slope=0.125)),
+        (quantized_relu(8, 4, negative_slope=1.0)),
+        (quantized_relu(10, negative_slope=0.25)),
+        (quantized_relu(10, 5, negative_slope=0.5)),
+        (quantized_relu(10, 5, negative_slope=0.25)),
+    ],
+)
+@pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus'])
+@pytest.mark.parametrize('io_type', ['io_parallel', 'io_stream'])
+def test_quantizer(randX_1000_1, quantizer, backend, io_type):
+    '''
+    Test a single quantizer as an Activation function.
+    Using numpy's assert_allclose to check that the differnce between the converted layer and qkeras' is lower than of 10^-5.
+    '''
+    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')
+    output_dir = str(
+        test_root_path
+        / 'hls4mlprj_qkeras_quantizer_{}_{}_{}_{}_{}'.format(
+            quantizer.__class__.__name__, quantizer.bits, quantizer.integer, backend, io_type
+        )
+    )
+    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)

test/pytest/test_qkeras.py

@@ -273,6 +273,7 @@ def randX_1000_1():
         (quantized_relu(8, 4)),
         (quantized_relu(10)),
         (quantized_relu(10, 5)),
+        (quantized_relu(10, 5, negative_slope=0.25)),
     ],
 )
 @pytest.mark.parametrize('backend', ['Vivado', 'Vitis', 'Quartus'])