New backend development framework

.gitignore

@@ -9,4 +9,5 @@ vivado_prj
 my-hls-test
 *.tar.gz
 docs/_build
-docs/autodoc/*
+docs/autodoc/*
+hls4mlprj_*

docs/api/configuration.rst

@@ -65,7 +65,7 @@ It looks like this:
    OutputPredictions: keras/KERAS_3layer_predictions.dat
    OutputDir: my-hls-test
    ProjectName: myproject
-   XilinxPart: xcku115-flvb2104-2-i
+   Device: xcku115-flvb2104-2-i
    ClockPeriod: 5
 
    IOType: io_parallel # options: io_serial/io_parallel
@@ -88,7 +88,7 @@ There are a number of configuration options that you have.  Let's go through the
 * **InputData/OutputPredictions**\ : path to your input/predictions of the model. If none is supplied, then hls4ml will create aritificial data for simulation. The data used above in the example can be found `here <https://cernbox.cern.ch/index.php/s/2LTJVVwCYFfkg59>`__. We also support ``npy`` data files. We welcome suggestions on more input data types to support. 
 * **OutputDir**\ : the output directory where you want your HLS project to appear
 * **ProjectName**\ : the name of the HLS project IP that is produced
-* **XilinxPart**\ : the particular FPGA part number that you are considering, here it's a Xilinx Virtex-7 FPGA
+* **Device**\ : the particular FPGA part number that you are considering, here it's a Xilinx Virtex-7 FPGA
 * **ClockPeriod**\ : the clock period, in ns, at which your algorithm runs
   Then you have some optimization parameters for how your algorithm runs:
 * **IOType**\ : your options are ``io_parallel`` or ``io_serial`` where this really defines if you are pipelining your algorithm or not

docs/api/profiling.rst

@@ -8,7 +8,7 @@ Using a low precision can help reduce the FPGA resource usage of a model, but ma
 
 Profiling uses some extra dependencies, to install these, run ``pip install hls4ml[profiling]``. The profiling tools are provided as a ``Python`` module which you can use.
 
-Three types of objects can be provided: **a Keras model object**\ , **test data**\ , and an **HLSModel object**.
+Three types of objects can be provided: **a Keras model object**\ , **test data**\ , and an **ModelGraph object**.
 You will need to initialise these objects by using a trained model, loading a model from a file, and loading your data. The Keras model and data each need to be in the format that would normally allow you to run, e.g. ``model.predict(X)``.
 
 .. code-block:: python
@@ -47,11 +47,11 @@ When different combinations of the input objects are given, different plots will
 
 1) Only Keras model: only the weights profile plot will be produced, the activation profile will be ``None``. No grey boxes representing the data types will be shown.
 
-2) Only HLSModel (or HLSModel and Keras model): only the weights profile plot will be produced, with grey boxes indicating the data types from the HLSModel. 
+2) Only ModelGraph (or ModelGraph and Keras model): only the weights profile plot will be produced, with grey boxes indicating the data types from the ModelGraph. 
 
 3) Keras model and data (\ ``X``\ ): both the weights profile and activation profile will be produced. No grey boxes representing the data types will be shown.
 
-4) Keras model, HLSModel, and data: both weights and activation profiles are produced, with grey boxes indicating the data types from the HLSModel.
+4) Keras model, ModelGraph, and data: both weights and activation profiles are produced, with grey boxes indicating the data types from the ModelGraph.
 
 Each box shows the median and quartiles of the distribution. The grey shaded boxes show the range which can be represented with the ``hls4ml`` config file used.
 

hls4ml/backends/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import absolute_import
+
+from hls4ml.backends.backend import Backend, register_backend, get_backend, get_available_backends
+from hls4ml.backends.fpga.fpga_backend import FPGABackend
+from hls4ml.backends.vivado.vivado_backend import VivadoBackend
+from hls4ml.backends.vivado_accelerator.vivado_accelerator_backend import VivadoAcceleratorBackend
+from hls4ml.backends.vivado_accelerator.vivado_accelerator_config import VivadoAcceleratorConfig
+from hls4ml.backends.quartus.quartus_backend import QuartusBackend
+
+register_backend('Vivado', VivadoBackend)
+register_backend('VivadoAccelerator', VivadoAcceleratorBackend)
+register_backend('Quartus', QuartusBackend)

hls4ml/backends/backend.py

@@ -0,0 +1,78 @@
+import inspect
+import os
+
+from hls4ml.backends.template import Template
+from hls4ml.model.flow import get_backend_flows
+from hls4ml.model.optimizer import LayerOptimizerPass, register_pass, extract_optimizers_from_path, extract_optimizers_from_object, get_backend_passes, get_optimizer
+
+
+class Backend(object):
+    def __init__(self, name):
+        self.name = name
+        self._init_optimizers()
+
+    def _init_optimizers(self):
+        optimizers = {}
+        optimizers.update(self._init_class_optimizers())
+        optimizers.update(self._init_file_optimizers())
+        for opt_name, opt in optimizers.items():
+            self.register_pass(opt_name, opt)
+
+    def _init_class_optimizers(self):
+        class_optimizers = extract_optimizers_from_object(self)
+        return class_optimizers
+
+    def _init_file_optimizers(self):
+        opt_path = os.path.dirname(inspect.getfile(self.__class__)) + '/passes'
+        module_path = self.__module__[:self.__module__.rfind('.')] + '.passes'
+        file_optimizers = extract_optimizers_from_path(opt_path, module_path, self)
+        return file_optimizers
+
+    def _get_layer_initializers(self):
+        all_initializers = { name:get_optimizer(name) for name in get_backend_passes(self.name) if isinstance(get_optimizer(name), LayerOptimizerPass) }
+
+        # Sort through the initializers based on the base class (e.g., to apply 'Layer' optimizers before 'Dense')
+        sorted_initializers = sorted(all_initializers.items(), key=lambda x: len(x[1].layer_class.mro()))
+
+        # Return only the names of the initializers
+        return [opt[0] for opt in sorted_initializers]
+
+    def _get_layer_templates(self):
+        return [name for name in get_backend_passes(self.name) if isinstance(get_optimizer(name), Template)]
+
+    def create_initial_config(self, **kwargs):
+        raise NotImplementedError
+
+    def create_layer_class(self, layer_class):
+        raise NotImplementedError
+
+    def get_available_flows(self):
+        return get_backend_flows(self.name)
+
+    def get_default_flow(self):
+        raise NotImplementedError
+
+    def register_source(self, file_name, source, destination_dir='nnet_utils'):
+        raise NotImplementedError
+
+    def register_pass(self, name, opt_cls):
+        register_pass(name, opt_cls, backend=self.name)
+
+    def register_template(self, template_cls):
+        template = template_cls()
+        register_pass(template.get_name(), template, backend=self.name)
+
+
+backend_map = {}
+
+def register_backend(name, backend_cls):
+    if name.lower() in backend_map:
+        raise Exception('Backend {} already registered'.format(name))
+
+    backend_map[name.lower()] = backend_cls()
+
+def get_backend(name):
+    return backend_map[name.lower()]
+
+def get_available_backends():
+    return list(backend_map.keys())