code: def __init__(self, config, model_inputs, model_outputs):
      self.config = config.config
      self.board = self.config.get("AcceleratorConfig", {}).get(
          "Board", "pynq-z2"
      )
      self.supported_boards = json.load(
          open(os.path.dirname(__file__) + "/supported_boards.json")
      )
      if self.board in self.supported_boards.keys():
          board_info = self.supported_boards[self.board]
          self.part = board_info["part"]
      else:
          raise Exception(
              "The board does not appear in supported_boards.json file"
          )
  
      if self.config.get("Part") is not None:
          if self.config.get("Part") != self.part:
              print(
                  "WARNING: You set a Part that does not correspond to the Board you specified. The correct "
                  "Part is now set."
              )
              self.config["Part"] = self.part
      accel_config = self.config.get("AcceleratorConfig", None)
      if accel_config is not None:
          prec = accel_config.get("Precision")
          if prec is None:
              raise Exception(
                  "Precision must be provided in the AcceleratorConfig"
              )
          else:
              if (
                  prec.get("Input") is None
                  or prec.get("Output") is None
              ):
                  raise Exception(
                      "Input and Output fields must be provided in the AcceleratorConfig->Precision"
                  )
      else:
          accel_config = {
              "Precision": {"Input": "float", "Output": "float"},
              "Driver": "python",
              "Interface": "axi_stream",
          }
          config.config["AcceleratorConfig"] = accel_config
  
      self.interface = self.config["AcceleratorConfig"].get(
          "Interface", "axi_stream"
      )  # axi_stream, axi_master, axi_lite
      self.driver = self.config["AcceleratorConfig"].get(
          "Driver", "python"
      )  # python or c
      self.input_type = self.config["AcceleratorConfig"][
          "Precision"
      ].get(
          "Input", "float"
      )  # float, double or ap_fixed<a,b>
      self.output_type = self.config["AcceleratorConfig"][
          "Precision"
      ].get(
          "Output", "float"
      )  # float, double or ap_fixed<a,b>
      self.platform = self.config["AcceleratorConfig"].get(
          "Platform", "xilinx_u250_xdma_201830_2"
      )  # Get platform folder name
  
      assert (
          len(model_inputs) == 1
      ), "Only models with one input tensor are currently supported by VivadoAcceleratorBackend"
      assert (
          len(model_outputs) == 1
      ), "Only models with one output tensor are currently supported by VivadoAcceleratorBackend"
      self.inp = model_inputs[0]
      self.out = model_outputs[0]
      inp_axi_t = self.input_type
      out_axi_t = self.output_type
  
      if inp_axi_t not in ["float", "double"]:
          self.input_type = self._next_factor8_type(
              config.backend.convert_precision_string(inp_axi_t)
          )
      if out_axi_t not in ["float", "double"]:
          self.output_type = self._next_factor8_type(
              config.backend.convert_precision_string(out_axi_t)
          )
  
      if self.input_type == "float":
          self.input_bitwidth = 32
      elif self.input_type == "double":
          self.input_bitwidth = 64
      else:
          self.input_bitwidth = config.backend.convert_precision_string(
              inp_axi_t
          ).width
  
      if out_axi_t == "float":
          self.output_bitwidth = 32
      elif out_axi_t == "double":
          self.output_bitwidth = 64
      else:
          self.output_bitwidth = (
              config.backend.convert_precision_string(out_axi_t).width
          )
  
imports: import json
  import os
  import numpy
  from hls4ml.model.layers import FixedPrecisionType, IntegerPrecisionType
label_desc: Use image node_id 1 to create a new VivadoAcceleratorConfig object  with example: obj = VivadoAcceleratorConfig(config, model_inputs, model_outputs)