Support for floating point types (#1307)

* Support for floating point types

* Use C++23 types for bfloat16 and half

* Implement << op

* Use floating-point headers only if the types require them

* Print a warning if new C++ types (half and bloat16) are used

* Fix typo

Author: vloncar

hls4ml/backends/fpga/fpga_backend.py

@@ -40,10 +40,12 @@
 from hls4ml.model.types import (
     ExponentPrecisionType,
     FixedPrecisionType,
+    FloatPrecisionType,
     IntegerPrecisionType,
     PrecisionType,
     RoundingMode,
     SaturationMode,
+    StandardFloatPrecisionType,
     UnspecifiedPrecisionType,
     XnorPrecisionType,
 )
@@ -362,11 +364,22 @@ def convert_precision_string(cls, precision):
         if precision.lower() == 'auto':
             return cls._convert_auto_type(precision)
 
+        if precision in ['float', 'double', 'half', 'bfloat16'] or precision.startswith(
+            ('ap_float', 'ac_std_float', 'std_float')
+        ):
+            return cls._convert_standard_float_type(precision)
+
+        if precision.startswith('ac_float'):
+            return cls._convert_ac_float_type(precision)
+
         if precision.startswith('ac_'):
             return cls._convert_ac_type(precision)
-        else:
+
+        if precision.startswith(('ap_', 'fixed', 'ufixed', 'int', 'uint')):  # We parse AP notation even without 'ap_' prefix
             return cls._convert_ap_type(precision)
 
+        raise ValueError(f'Unsupported precision type: {precision}')
+
     @classmethod
     def _convert_ap_type(cls, precision):
         '''
@@ -435,6 +448,44 @@ def _convert_ac_type(cls, precision):
         elif 'int' in precision:
             return IntegerPrecisionType(width, signed)
 
+    @classmethod
+    def _convert_standard_float_type(cls, precision):
+        # Some default values
+        if precision == 'float':
+            return StandardFloatPrecisionType(width=32, exponent=8, use_cpp_type=True)
+        if precision == 'double':
+            return StandardFloatPrecisionType(width=64, exponent=11, use_cpp_type=True)
+        if precision == 'half':
+            return StandardFloatPrecisionType(width=16, exponent=5, use_cpp_type=True)
+        if precision == 'bfloat16':
+            return StandardFloatPrecisionType(width=16, exponent=8, use_cpp_type=True)
+
+        # If it is a float type, parse the width and exponent
+        bits = re.search('.+<(.+?)>', precision).group(1).split(',')
+        if len(bits) == 2:
+            width = int(bits[0])
+            exponent = int(bits[1])
+            return StandardFloatPrecisionType(width=width, exponent=exponent, use_cpp_type=False)
+        else:
+            raise ValueError(f'Invalid standard float precision format: {precision}')
+
+    @classmethod
+    def _convert_ac_float_type(cls, precision):
+        # If it is a float type, parse the width and exponent
+        bits = re.search('.+<(.+?)>', precision).group(1).split(',')
+        if len(bits) == 3 or len(bits) == 4:
+            mantissa = int(bits[0])
+            integer = int(bits[1])
+            exponent = int(bits[2])
+            width = mantissa + exponent
+            if len(bits) == 4:
+                round_mode = RoundingMode.from_string(bits[3])
+            else:
+                round_mode = None
+            return FloatPrecisionType(width=width, integer=integer, exponent=exponent, rounding_mode=round_mode)
+        else:
+            raise ValueError(f'Invalid ac_float precision format: {precision}')
+
     @classmethod
     def _convert_auto_type(cls, precision):
         '''

hls4ml/backends/fpga/fpga_types.py

@@ -5,9 +5,11 @@
     ExponentPrecisionType,
     ExponentType,
     FixedPrecisionType,
+    FloatPrecisionType,
     IntegerPrecisionType,
     NamedType,
     PackedType,
+    StandardFloatPrecisionType,
     XnorPrecisionType,
 )
 
@@ -51,6 +53,25 @@ def definition_cpp(self):
         return typestring
 
 
+class APFloatPrecisionDefinition(PrecisionDefinition):
+    def definition_cpp(self):
+        raise NotImplementedError(
+            'FloatPrecisionType is not supported in AP type precision definitions. Use StandardFloatPrecisionType instead.'
+        )
+
+
+class APStandardFloatPrecisionDefinition(PrecisionDefinition):
+    def definition_cpp(self):
+        typestring = str(self)
+        if typestring.startswith('std_float'):
+            typestring = typestring.replace('std_float', 'ap_float')
+        elif typestring == 'half':
+            typestring = 'std::float16_t'
+        elif typestring == 'bfloat16':
+            typestring = 'std::bfloat16_t'
+        return typestring
+
+
 class ACIntegerPrecisionDefinition(PrecisionDefinition):
     def definition_cpp(self):
         typestring = f'ac_int<{self.width}, {str(self.signed).lower()}>'
@@ -94,12 +115,40 @@ def definition_cpp(self):
         return typestring
 
 
+class ACFloatPrecisionDefinition(PrecisionDefinition):
+    def _rounding_mode_cpp(self, mode):
+        if mode is not None:
+            return 'AC_' + str(mode)
+
+    def definition_cpp(self):
+        args = [
+            self.width,
+            self.integer,
+            self.exponent,
+            self._rounding_mode_cpp(self.rounding_mode),
+        ]
+        if args[3] == 'AC_TRN':
+            # This is the default, so we won't write the full definition for brevity
+            args[3] = None
+        args = ','.join([str(arg) for arg in args[:5] if arg is not None])
+        typestring = f'ac_float<{args}>'
+        return typestring
+
+
+class ACStandardFloatPrecisionDefinition(PrecisionDefinition):
+    def definition_cpp(self):
+        typestring = str(self)
+        if typestring.startswith('std_float'):
+            typestring = 'ac_' + typestring
+        return typestring
+
+
 class PrecisionConverter:
     def convert(self, precision_type):
         raise NotImplementedError
 
 
-class FixedPrecisionConverter(PrecisionConverter):
+class FPGAPrecisionConverter(PrecisionConverter):
     def __init__(self, type_map, prefix):
         self.type_map = type_map
         self.prefix = prefix
@@ -124,25 +173,29 @@ def convert(self, precision_type):
             raise Exception(f'Cannot convert precision type to {self.prefix}: {precision_type.__class__.__name__}')
 
 
-class APTypeConverter(FixedPrecisionConverter):
+class APTypeConverter(FPGAPrecisionConverter):
     def __init__(self):
         super().__init__(
             type_map={
                 FixedPrecisionType: APFixedPrecisionDefinition,
                 IntegerPrecisionType: APIntegerPrecisionDefinition,
+                FloatPrecisionType: APFloatPrecisionDefinition,
+                StandardFloatPrecisionType: APStandardFloatPrecisionDefinition,
                 ExponentPrecisionType: APIntegerPrecisionDefinition,
                 XnorPrecisionType: APIntegerPrecisionDefinition,
             },
             prefix='AP',
         )
 
 
-class ACTypeConverter(FixedPrecisionConverter):
+class ACTypeConverter(FPGAPrecisionConverter):
     def __init__(self):
         super().__init__(
             type_map={
                 FixedPrecisionType: ACFixedPrecisionDefinition,
                 IntegerPrecisionType: ACIntegerPrecisionDefinition,
+                FloatPrecisionType: ACFloatPrecisionDefinition,
+                StandardFloatPrecisionType: ACStandardFloatPrecisionDefinition,
                 ExponentPrecisionType: ACIntegerPrecisionDefinition,
                 XnorPrecisionType: ACIntegerPrecisionDefinition,
             },

hls4ml/backends/oneapi/oneapi_types.py

@@ -6,11 +6,15 @@
 
 from hls4ml.backends.fpga.fpga_types import (
     ACFixedPrecisionDefinition,
+    ACFloatPrecisionDefinition,
     ACIntegerPrecisionDefinition,
-    FixedPrecisionConverter,
+    ACStandardFloatPrecisionDefinition,
+    FloatPrecisionType,
+    FPGAPrecisionConverter,
     HLSTypeConverter,
     NamedTypeConverter,
     PrecisionDefinition,
+    StandardFloatPrecisionType,
     TypeDefinition,
     TypePrecisionConverter,
     VariableDefinition,
@@ -35,12 +39,14 @@ def definition_cpp(self):
         return typestring
 
 
-class OneAPIACTypeConverter(FixedPrecisionConverter):
+class OneAPIACTypeConverter(FPGAPrecisionConverter):
     def __init__(self):
         super().__init__(
             type_map={
                 FixedPrecisionType: ACFixedPrecisionDefinition,
                 IntegerPrecisionType: ACIntegerPrecisionDefinition,
+                FloatPrecisionType: ACFloatPrecisionDefinition,
+                StandardFloatPrecisionType: ACStandardFloatPrecisionDefinition,
                 ExponentPrecisionType: ACExponentPrecisionDefinition,
                 XnorPrecisionType: ACIntegerPrecisionDefinition,
             },

hls4ml/backends/vitis/passes/feature_check.py

@@ -1,4 +1,5 @@
 from hls4ml.model.optimizer import OptimizerPass
+from hls4ml.model.types import StandardFloatPrecisionType
 
 
 class ValidateConvImplementation(OptimizerPass):
@@ -87,3 +88,23 @@ def transform(self, model, node):
             f'WARNING: "{node.model.config.config["IOType"]}" IO Type is not supported in Vitis backend '
             f'for "{node.name}" ({node.class_name}). Please use "io_parallel".'
         )
+
+
+class ValidateStdCppTypes(OptimizerPass):
+    def match(self, node):
+        return True
+
+    def transform(self, model, node):
+        prec_types = [prec_type.precision for prec_type in node.get_layer_precision().values()]
+        prec_types = [
+            prec_type
+            for prec_type in prec_types
+            if isinstance(prec_type, StandardFloatPrecisionType)
+            and prec_type.use_cpp_type
+            and str(prec_type) not in ('float', 'double')
+        ]
+        if len(prec_types) > 0:
+            print(
+                f'WARNING: Layer "{node.name}" uses C++ types that are not synthesizable with Vitis backend. '
+                'Use only for testing purposes.'
+            )

hls4ml/backends/vitis/vitis_backend.py

@@ -30,6 +30,7 @@ def _register_flows(self):
             'vitis:validate_resource_unrolled_strategy',
             'vitis:validate_bidirectional_merge_mode',
             'vitis:validate_bidirectional_io_type',
+            'vitis:validate_std_cpp_types',
         ]
         validation_flow = register_flow('validation', validation_passes, requires=['vivado:init_layers'], backend=self.name)