code: def run_transforms(
      data,
      callables,
      inverse=False,
      log_prefix="POST",
      log_name="Transform",
      use_compose=False,
  ):
      """
      Run Transforms
  
      :param data: Input data dictionary
      :param callables: List of transforms or callable objects
      :param inverse: Run inverse instead of call/forward function
      :param log_prefix: Logging prefix (POST or PRE)
      :param log_name: Type of callables for logging
      :param use_compose: Use Compose to run individual callables
      :return: Processed data after running transforms
      """
      logger.setLevel(data.get("logging", "INFO").upper())
      logger.info(f"{log_prefix} - Run {log_name}(s)")
      logger.info(f"{log_prefix} - Input Keys: {list(data.keys())}")
  
      if not callables:
          return data
  
      compose = Compose()
      if isinstance(callables, Compose):
          callables = callables.transforms
      elif callable(callables):
          callables = [callables]
  
      for t in callables:
          name = t.__class__.__name__
          start = time.time()
  
          dump_data(data)
          if inverse:
              if hasattr(t, "inverse"):
                  data = t.inverse(data)
              else:
                  raise MONAILabelException(
                      MONAILabelError.TRANSFORM_ERROR,
                      f"{log_name} '{t.__class__.__name__}' has no invert method",
                  )
          elif callable(t):
              if use_compose:
                  compose.transforms = [t]
                  data = compose(data)
              else:
                  data = t(data)
          else:
              raise MONAILabelException(
                  MONAILabelError.TRANSFORM_ERROR,
                  f"{log_name} '{t.__class__.__name__}' is not callable",
              )
  
          latency = round(time.time() - start, 4)
          if data:
              stage = log_prefix.lower()
              if data.get("latencies") is None:
                  data["latencies"] = {}
              if data["latencies"].get(stage) is None:
                  data["latencies"][stage] = {}
              data["latencies"][stage][name] = latency
  
          logger.info(
              f"{log_prefix} - {log_name} ({name}): Time: {latency}; {shape_info(data)}"
          )
          logger.debug(
              "-----------------------------------------------------------------------------"
          )
  
      dump_data(data)
      return data
  
imports: import logging
  import time
  from monai.transforms import Compose
  from monailabel.interfaces.exception import MONAILabelError, MONAILabelException
label_desc: Use image node_id 3 for calling a global function with example usage: run_transforms(data, callables, inverse, log_prefix, log_name, use_compose) and returns: data, data