code: def to_pil_image(
      image: Union[
          np.ndarray,
          "PIL.Image.Image",
          "torch.Tensor",
          "tf.Tensor",
          "jnp.ndarray",
      ],
      do_rescale: Optional[bool] = None,
      input_data_format: Optional[Union[str, ChannelDimension]] = None,
  ) -> "PIL.Image.Image":
      """
      Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if
      needed.
  
      Args:
          image (`PIL.Image.Image` or `numpy.ndarray` or `torch.Tensor` or `tf.Tensor`):
              The image to convert to the `PIL.Image` format.
          do_rescale (`bool`, *optional*):
              Whether or not to apply the scaling factor (to make pixel values integers between 0 and 255). Will default
              to `True` if the image type is a floating type and casting to `int` would result in a loss of precision,
              and `False` otherwise.
          input_data_format (`ChannelDimension`, *optional*):
              The channel dimension format of the input image. If unset, will use the inferred format from the input.
  
      Returns:
          `PIL.Image.Image`: The converted image.
      """
      requires_backends(to_pil_image, ["vision"])
  
      if isinstance(image, PIL.Image.Image):
          return image
  
      # Convert all tensors to numpy arrays before converting to PIL image
      if is_torch_tensor(image) or is_tf_tensor(image):
          image = image.numpy()
      elif is_jax_tensor(image):
          image = np.array(image)
      elif not isinstance(image, np.ndarray):
          raise ValueError(
              "Input image type not supported: {}".format(type(image))
          )
  
      # If the channel has been moved to first dim, we put it back at the end.
      image = to_channel_dimension_format(
          image, ChannelDimension.LAST, input_data_format
      )
  
      # If there is a single channel, we squeeze it, as otherwise PIL can't handle it.
      image = (
          np.squeeze(image, axis=-1) if image.shape[-1] == 1 else image
      )
  
      # PIL.Image can only store uint8 values so we rescale the image to be between 0 and 255 if needed.
      do_rescale = (
          _rescale_for_pil_conversion(image)
          if do_rescale is None
          else do_rescale
      )
  
      if do_rescale:
          image = rescale(image, 255)
  
      image = image.astype(np.uint8)
      return PIL.Image.fromarray(image)
  
imports: import warnings
  from typing import Iterable, List, Optional, Tuple, Union
  import numpy
  from .image_utils import ChannelDimension, ImageInput, get_channel_dimension_axis, get_image_size, infer_channel_dimension_format
  from .utils import ExplicitEnum, TensorType, is_jax_tensor, is_tf_tensor, is_torch_tensor
  from .utils.import_utils import is_flax_available, is_tf_available, is_torch_available, is_vision_available, requires_backends
label_desc: Use image node_id 4 for calling a global function with example usage: to_pil_image(image, do_rescale, input_data_format) and returns: PIL, image