Single stream

hls4ml/backends/fpga/fpga_backend.py

@@ -103,18 +103,69 @@ def get_layer_mult_size(self, layer):
             n_out_recr = n_out
             return n_in, n_out, n_in_recr, n_out_recr
 
+        # 2022 12
+        if 'TimeDistributed' in layer.class_name:
+            n_in = layer.get_attr('n_in')
+            n_hid = layer.get_attr('n_hid')
+            n_out = layer.get_attr('n_out')
+            return n_in, n_hid, n_out
+
         raise Exception(f'Cannot get mult size for layer {layer.name} ({layer.class_name})')
+
+    # 2022 12
+    # For Dense_ss , rf is chosen based on nout only---------------------------------------------
+    def get_valid_reuse_factors_nout(self, n_out, layer):
+        max_rf = n_out
+        valid_reuse_factors = []
+        for rf in range(1, max_rf + 1):
+            _assert = self._validate_reuse_factor_nout(n_out, rf, layer)
+            if _assert:
+                valid_reuse_factors.append(rf)
+        return valid_reuse_factors
 
-    def get_valid_reuse_factors(self, n_in, n_out):
+    def _validate_reuse_factor_nout(self, n_out, rf, layer):
+
+        # take the input_precision into account 
+        input_precision = layer.get_input_variable().type.precision.width
+
+        _assert = (((n_out) % rf) == 0)
+
+        block_factor = int(math.ceil((n_out) / float(rf)))
+        _assert = _assert and (input_precision * block_factor) < 65536
+
+        return _assert
+
+    def set_closest_reuse_factor_nout(self, layer, n_out, attribute='reuse_factor'):
+        assert attribute is not None, 'Reuse factor attribute cannot be None'
+
+        valid_rf = self.get_valid_reuse_factors_nout(n_out, layer)
+        chosen_rf = layer.get_attr(attribute)
+
+        if chosen_rf not in valid_rf:
+            closest_rf = self.get_closest_reuse_factor(valid_rf, chosen_rf)
+
+            # 2022 CHIRUI USE 2ND MAX RF
+            #closest_rf = valid_rf[-2]
+
+            print('WARNING: Invalid ReuseFactor={} in layer "{}". Using ReuseFactor={} instead. Valid ReuseFactor(s): {}.'
+                .format(chosen_rf, layer.name, closest_rf, ','.join(map(str, valid_rf))))
+            layer.set_attr(attribute, closest_rf)
+    #-----------------------------------------------------------------------------------------------    
+
+    def get_valid_reuse_factors(self, n_in, n_out, layer):
         max_rf = n_in * n_out
         valid_reuse_factors = []
         for rf in range(1, max_rf + 1):
-            _assert = self._validate_reuse_factor(n_in, n_out, rf)
+            _assert = self._validate_reuse_factor(n_in, n_out, rf, layer)
             if _assert:
                 valid_reuse_factors.append(rf)
         return valid_reuse_factors
 
-    def _validate_reuse_factor(self, n_in, n_out, rf):
+    def _validate_reuse_factor(self, n_in, n_out, rf, layer):
+
+        # take the input_precision into account 
+        input_precision = layer.get_input_variable().type.precision.width
+
         multfactor = min(n_in, rf)
         multiplier_limit = int(math.ceil((n_in * n_out) / float(multfactor)))
         #
@@ -126,7 +177,30 @@ def _validate_reuse_factor(self, n_in, n_out, rf):
         # THIS ASSERTION IS FOR QoR AND EXECUTION TIME
         #
         _assert = _assert and (((n_in * n_out) % rf) == 0)
-
+
+        # 2022 CHIRUI
+        #
+        # THIS ASSERTION IS FOR MAKING SURE THAT (INPUT_PRECISION * BLOCK_FACTOR) WON'T EXCEED VIVADO 65535 BITWIDTH
+        # IT IS USED FOR THE RESHAPE PRAGMA OF WEIGHTS AND BIAS IN THE DENSE LAYER
+
+        ## get the block_factor, it is valid for first 2 kinds of the dense layers caculation
+        _rf = min(n_in * n_out, rf)
+        block_factor = int(math.ceil((n_in * n_out) / float(_rf)))
+        _assert = _assert and (input_precision * block_factor) < 65536
+
+        # ------------------Several Dense choices-----------------
+        #
+        # THIS ASSERTION IS FOR USING 1ST KIND OF THE DENSE LAYER
+        #
+        #_assert = _assert and _rf <= n_in
+        #
+        # THIS ASSERTION IS FOR USING THE MAX RF IN 1ST KIND OF THE DENSE LAYER
+        _assert = _assert and _rf == n_in
+        #
+        # THIS ASSERTION IS FOR USING 2ND KIND OF THE DENSE LAYER WITH MAX RF
+        #
+        #_assert = _assert and _rf == (n_in * n_out)
+
         return _assert
 
     def get_closest_reuse_factor(self, valid_rf, chosen_rf):
@@ -148,11 +222,16 @@ def get_closest_reuse_factor(self, valid_rf, chosen_rf):
 
     def set_closest_reuse_factor(self, layer, n_in, n_out, attribute='reuse_factor'):
         assert attribute is not None, 'Reuse factor attribute cannot be None'
-
-        valid_rf = self.get_valid_reuse_factors(n_in, n_out)
+                
+        valid_rf = self.get_valid_reuse_factors(n_in, n_out, layer)
         chosen_rf = layer.get_attr(attribute)
+
         if chosen_rf not in valid_rf:
             closest_rf = self.get_closest_reuse_factor(valid_rf, chosen_rf)
+
+            # 2022 CHIRUI USE 2ND MAX RF
+            #closest_rf = valid_rf[-2]
+
             print('WARNING: Invalid ReuseFactor={} in layer "{}". Using ReuseFactor={} instead. Valid ReuseFactor(s): {}.'
                 .format(chosen_rf, layer.name, closest_rf, ','.join(map(str, valid_rf))))
             layer.set_attr(attribute, closest_rf)

hls4ml/backends/fpga/fpga_types.py

@@ -143,7 +143,7 @@ def convert_precision(self, precision_converter):
 class PackedTypeConverter(TypeDefinition, TypePrecisionConverter):
     def definition_cpp(self):
         n_elem_expr = '/' if self.unpack else '*'
-        return 'typedef nnet::array<{precision}, {n_elem}> {name};\n'.format(name=self.name, precision=self.precision.definition_cpp(), n_elem=str(self.n_elem) + n_elem_expr + str(self.n_pack))
+        return 'typedef {precision} {name};\n'.format(name=self.name, precision=self.precision.definition_cpp())
 
 class HLSTypeConverter(object):
     def __init__(self, precision_converter):
@@ -351,4 +351,4 @@ def convert(cls, weight_var):
 
 #endregion
 
-#endregion
+#endregion

hls4ml/backends/fpga/passes/clone.py

@@ -26,7 +26,7 @@ def format(self, node):
             params['output' + str(i + 1)] = node.variables[node.outputs[i]].name
 
         if self.template is None:
-            self.template = 'nnet::clone_stream<{input_t}, {output_t}, {size}>({input}, ' + \
+            self.template = 'nnet::clone_stream_ss<{input_t}, {output_t}, {size}>({input}, ' + \
                             ', '.join(['{output' + str(i + 1) + '}' for i in range(len(node.outputs))]) + \
                             ');'
 

hls4ml/backends/vivado/passes/conv_same_pad.py

@@ -1,5 +1,5 @@
 from hls4ml.model.optimizer import OptimizerPass
-from hls4ml.model.layers import Conv1D, SeparableConv1D, Conv2D, SeparableConv2D
+from hls4ml.model.layers import Conv1D, SeparableConv1D, Conv2D, SeparableConv2D, DepthwiseConv2D
 
 class InsertZeroPaddingBeforeConv1D(OptimizerPass):
     name = 'insert_zero_padding_before_conv1d'
@@ -50,7 +50,7 @@ class InsertZeroPaddingBeforeConv2D(OptimizerPass):
     name = 'insert_zero_padding_before_conv2d'
 
     def match(self, node):
-        is_match = isinstance(node, (Conv2D, SeparableConv2D)) and \
+        is_match = isinstance(node, (Conv2D, SeparableConv2D, DepthwiseConv2D)) and \
             node.get_attr('padding') == 'same' and \
             node.get_attr('filt_height') != 1 and node.get_attr('filt_width') != 1
         return is_match

hls4ml/backends/vivado/passes/conv_stream.py

@@ -1,10 +1,10 @@
 from hls4ml.model.optimizer import OptimizerPass
-from hls4ml.model.layers import Conv1D, SeparableConv1D, Conv2D, SeparableConv2D
+from hls4ml.model.layers import Conv1D, SeparableConv1D, Conv2D, SeparableConv2D, DepthwiseConv2D
 
 class GenerateConvStreamingInstructions(OptimizerPass):
     ''' Generates the instructions for streaming implementation of CNNs '''
     def match(self, node):
-        return isinstance(node, (Conv1D, SeparableConv1D, Conv2D, SeparableConv2D))
+        return isinstance(node, (Conv1D, SeparableConv1D, Conv2D, SeparableConv2D, DepthwiseConv2D))
 
     def transform(self, model, node):
         node_class = node.__class__.__name__

hls4ml/backends/vivado/passes/convolution_templates.py

@@ -128,8 +128,8 @@ def format(self, node):
 }};
 const ap_uint<config{index}::filt_height * config{index}::filt_width> config{index}::pixels[] = {{{instructions}}};\n"""
 
-conv2d_function_template = 'nnet::conv_2d_{data_format}<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
-depthconv2d_function_template = 'nnet::depthwise_conv_2d_{data_format}<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
+conv2d_function_template = 'nnet::conv_2d_{data_format}_ss<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
+depthconv2d_function_template = 'nnet::depthwise_conv_2d_{data_format}_ss<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
 
 conv2d_include_list = ['nnet_utils/nnet_conv2d.h', 'nnet_utils/nnet_conv2d_stream.h']
 
@@ -184,8 +184,8 @@ def __init__(self):
     typedef {pointwise_config} pointwise_config;
 }};\n"""
 
-sepconv1d_function_template = 'nnet::separable_conv_1d_{data_format}<{input_t}, {output_t}, {config}>({input}, {output}, {d}, {p}, {z}, {b});'
-sepconv2d_function_template = 'nnet::separable_conv_2d_{data_format}<{input_t}, {output_t}, {config}>({input}, {output}, {d}, {p}, {z}, {b});'
+sepconv1d_function_template = 'nnet::separable_conv_1d_{data_format}_ss<{input_t}, {output_t}, {config}>({input}, {output}, {d}, {p}, {z}, {b});'
+sepconv2d_function_template = 'nnet::separable_conv_2d_{data_format}_ss<{input_t}, {output_t}, {config}>({input}, {output}, {d}, {p}, {z}, {b});'
 
 sepconv1d_include_list = ['nnet_utils/nnet_conv1d.h', 'nnet_utils/nnet_sepconv1d_stream.h']
 sepconv2d_include_list = ['nnet_utils/nnet_conv2d.h', 'nnet_utils/nnet_sepconv2d_stream.h']
@@ -312,6 +312,7 @@ def format(self, node):
         mult_params['n_in'] = node.get_attr('n_chan') * node.get_attr('filt_height') * node.get_attr('filt_width')
         mult_params['n_out'] = node.get_attr('n_chan')
         mult_params['weight_t'] = node.get_weights('depthwise').type
+        mult_params['reuse'] = node.get_attr('reuse_factor_depthwise')
         mult_params['product_type'] = get_backend('vivado').product_type(node.get_input_variable().type.precision, node.get_weights('depthwise').type.precision)
         depthwise_mult_config = self.depthwise_mult_template.format(**mult_params)
 
@@ -344,6 +345,7 @@ def format(self, node):
         mult_params['n_in'] = node.get_attr('n_chan')
         mult_params['n_out'] = node.get_attr('n_filt')
         mult_params['weight_t'] = node.get_weights('pointwise').type
+        mult_params['reuse'] = node.get_attr('reuse_factor_pointwise')
         mult_params['product_type'] = get_backend('vivado').product_type(node.get_input_variable().type.precision, node.get_weights('pointwise').type.precision)
         pointwise_mult_config = self.pointwise_mult_template.format(**mult_params)
 

hls4ml/backends/vivado/passes/core_templates.py

@@ -1,6 +1,6 @@
 
 from hls4ml.backends.backend import get_backend
-from hls4ml.model.layers import Activation, BatchNormalization, Dense, Embedding, PReLU, ParametrizedActivation, Softmax
+from hls4ml.model.layers import Activation, BatchNormalization, Dense, DenseBatchnorm, Embedding, PReLU, ParametrizedActivation, Softmax
 from hls4ml.backends.template import LayerConfigTemplate, FunctionCallTemplate
 
 # Dense templates
@@ -22,13 +22,13 @@
     using product = nnet::product::{product_type}<x_T, y_T>;
 }};\n"""
 
-dense_function_template = 'nnet::dense<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
+dense_function_template = 'nnet::dense_ss<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
 
 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)
+        super().__init__((Dense, DenseBatchnorm))
         self.template = dense_config_template
 
     def format(self, node):
@@ -41,7 +41,7 @@ def format(self, node):
 
 class DenseFunctionTemplate(FunctionCallTemplate):
     def __init__(self):
-        super().__init__(Dense, include_header=dense_include_list)
+        super().__init__((Dense, DenseBatchnorm), include_header=dense_include_list)
         self.template = dense_function_template
 
     def format(self, node):
@@ -67,7 +67,7 @@ def format(self, node):
     using product = nnet::product::{product_type}<x_T, y_T>;
 }};\n"""
 
-batchnorm_function_template = 'nnet::normalize<{input_t}, {output_t}, {config}>({input}, {output}, {scale}, {bias});'
+batchnorm_function_template = 'nnet::normalize_ss<{input_t}, {output_t}, {config}>({input}, {output}, {scale}, {bias});'
 
 batchnorm_include_list = ['nnet_utils/nnet_batchnorm.h', 'nnet_utils/nnet_batchnorm_stream.h']
 
@@ -117,8 +117,8 @@ def format(self, node):
     typedef {inv_table_t.name} inv_table_t;
 }};\n"""
 
-activ_function_template = 'nnet::{activation}<{input_t}, {output_t}, {config}>({input}, {output});'
-param_activ_function_template = 'nnet::{activation}<{input_t}, {output_t}, {config}>({input}, {param}, {output});'
+activ_function_template = 'nnet::{activation}_ss<{input_t}, {output_t}, {config}>({input}, {output});'
+param_activ_function_template = 'nnet::{activation}_ss<{input_t}, {output_t}, {config}>({input}, {param}, {output});'
 
 activ_include_list = ['nnet_utils/nnet_activation.h', 'nnet_utils/nnet_activation_stream.h']