code: def __init__(
      self,
      run_fn,
      out_types,
      in_types,
      outs_ndim,
      ins_ndim,
      setup_fn=None,
      device="cpu",
      batch_processing=False,
      blocks=None,
      threads_per_block=None,
      **kwargs,
  ):
      if device == "gpu":
          NumbaFunction._check_minimal_numba_version()
          NumbaFunction._check_cuda_compatibility()
  
      # TODO(klecki): Normalize the types into lists first, than apply the checks
      assert len(in_types) == len(ins_ndim), (
          "Number of input types " "and input dimensions should match."
      )
      assert len(out_types) == len(outs_ndim), (
          "Number of output types "
          "and output dimensions should match."
      )
  
      if "float16" in dir(numba_types):
          for t in [*in_types, *out_types]:
              if t == dali_types.FLOAT16:
                  raise RuntimeError(
                      "Numba does not support float16 for "
                      "current Python version. "
                      "Python 3.7 or newer is required"
                  )
  
      if device == "gpu":
          assert (
              batch_processing is False
          ), "Currently batch processing for GPU is not supported."
          assert len(blocks) == 3, (
              "`blocks` array should contain 3 numbers, while received: "
              f"{len(blocks)}"
          )
          for i, block_dim in enumerate(blocks):
              assert block_dim > 0, (
                  "All dimensions should be positive. Value specified in "
                  f"`blocks` at index {i} is nonpositive: {block_dim}"
              )
  
          assert len(threads_per_block) == 3, (
              "`threads_per_block` array should contain 3 "
              f"numbers, while received: {len(threads_per_block)}"
          )
          for i, threads in enumerate(threads_per_block):
              assert threads > 0, (
                  "All dimensions should be positive. "
                  "Value specified in `threads_per_block` at index "
                  f"{i} is nonpositive: {threads}"
              )
  
      if not isinstance(outs_ndim, list):
          outs_ndim = [outs_ndim]
      if not isinstance(ins_ndim, list):
          ins_ndim = [ins_ndim]
      if not isinstance(out_types, list):
          out_types = [out_types]
      if not isinstance(in_types, list):
          in_types = [in_types]
  
      self._impl_name = "NumbaFuncImpl"
      self._schema = _b.GetSchema(self._impl_name)
      self._spec = _b.OpSpec(self._impl_name)
      self._device = device
  
      self._init_args, self._call_args = ops._separate_kwargs(kwargs)
      self._name = self._init_args.pop("name", None)
  
      for key, value in self._init_args.items():
          self._spec.AddArg(key, value)
  
      if device == "gpu":
          self.run_fn = self._get_run_fn_gpu(
              run_fn, out_types + in_types, outs_ndim + ins_ndim
          )
      else:
          self.run_fn = self._get_run_fn_cpu(
              run_fn,
              out_types,
              in_types,
              outs_ndim,
              ins_ndim,
              batch_processing,
          )
      self.setup_fn = self._get_setup_fn_cpu(setup_fn)
      self.out_types = out_types
      self.in_types = in_types
      self.outs_ndim = outs_ndim
      self.ins_ndim = ins_ndim
      self.num_outputs = len(out_types)
      self.batch_processing = batch_processing
      self._preserve = True
      self.blocks = blocks
      self.threads_per_block = threads_per_block
  
imports: from distutils.version import LooseVersion
  from nvidia.dali import backend
  from nvidia.dali.pipeline import Pipeline
  from nvidia.dali.data_node import DataNode
  from nvidia.dali import ops
  from nvidia.dali import types
  from numba import types
  from numba import njit, cfunc, carray, cuda
  import numpy
  import numba
label_desc: Use image node_id 14 to create a new NumbaFunction object  with example: obj = NumbaFunction(run_fn, out_types, in_types, outs_ndim, ins_ndim, setup_fn, device, batch_processing, blocks, threads_per_block)