code: def load_img(
      path,
      grayscale=False,
      color_mode="rgb",
      target_size=None,
      interpolation="nearest",
      keep_aspect_ratio=False,
  ):
      """Loads an image into PIL format.
  
      # Arguments
          path: Path (string), pathlib.Path object, or io.BytesIO stream to image file.
          grayscale: DEPRECATED use `color_mode="grayscale"`.
          color_mode: The desired image format. One of "grayscale", "rgb", "rgba".
              "grayscale" supports 8-bit images and 32-bit signed integer images.
              Default: "rgb".
          target_size: Either `None` (default to original size)
              or tuple of ints `(img_height, img_width)`.
          interpolation: Interpolation method used to resample the image if the
              target size is different from that of the loaded image.
              Supported methods are "nearest", "bilinear", and "bicubic".
              If PIL version 1.1.3 or newer is installed, "lanczos" is also
              supported. If PIL version 3.4.0 or newer is installed, "box" and
              "hamming" are also supported.
              Default: "nearest".
          keep_aspect_ratio: Boolean, whether to resize images to a target
                  size without aspect ratio distortion. The image is cropped in
                  the center with target aspect ratio before resizing.
  
      # Returns
          A PIL Image instance.
  
      # Raises
          ImportError: if PIL is not available.
          ValueError: if interpolation method is not supported.
          TypeError: type of 'path' should be path-like or io.Byteio.
      """
      if grayscale is True:
          warnings.warn(
              "grayscale is deprecated. Please use "
              'color_mode = "grayscale"'
          )
          color_mode = "grayscale"
      if pil_image is None:
          raise ImportError(
              "Could not import PIL.Image. "
              "The use of `load_img` requires PIL."
          )
      if isinstance(path, io.BytesIO):
          img = pil_image.open(path)
      elif isinstance(path, (Path, bytes, str)):
          if isinstance(path, Path):
              path = str(path.resolve())
          with open(path, "rb") as f:
              img = pil_image.open(io.BytesIO(f.read()))
      else:
          raise TypeError(
              "path should be path-like or io.BytesIO"
              ", not {}".format(type(path))
          )
  
      if color_mode == "grayscale":
          # if image is not already an 8-bit, 16-bit or 32-bit grayscale image
          # convert it to an 8-bit grayscale image.
          if img.mode not in ("L", "I;16", "I"):
              img = img.convert("L")
      elif color_mode == "rgba":
          if img.mode != "RGBA":
              img = img.convert("RGBA")
      elif color_mode == "rgb":
          if img.mode != "RGB":
              img = img.convert("RGB")
      else:
          raise ValueError(
              'color_mode must be "grayscale", "rgb", or "rgba"'
          )
      if target_size is not None:
          width_height_tuple = (target_size[1], target_size[0])
          if img.size != width_height_tuple:
              if interpolation not in _PIL_INTERPOLATION_METHODS:
                  raise ValueError(
                      "Invalid interpolation method {} specified. Supported "
                      "methods are {}".format(
                          interpolation,
                          ", ".join(_PIL_INTERPOLATION_METHODS.keys()),
                      )
                  )
              resample = _PIL_INTERPOLATION_METHODS[interpolation]
  
              if keep_aspect_ratio:
                  width, height = img.size
                  target_width, target_height = width_height_tuple
  
                  crop_height = (width * target_height) // target_width
                  crop_width = (height * target_width) // target_height
  
                  # Set back to input height / width
                  # if crop_height / crop_width is not smaller.
                  crop_height = min(height, crop_height)
                  crop_width = min(width, crop_width)
  
                  crop_box_hstart = (height - crop_height) // 2
                  crop_box_wstart = (width - crop_width) // 2
                  crop_box_wend = crop_box_wstart + crop_width
                  crop_box_hend = crop_box_hstart + crop_height
                  crop_box = [
                      crop_box_wstart,
                      crop_box_hstart,
                      crop_box_wend,
                      crop_box_hend,
                  ]
                  img = img.resize(
                      width_height_tuple, resample, box=crop_box
                  )
              else:
                  img = img.resize(width_height_tuple, resample)
      return img
  
file_path: keras-preprocessing/keras_preprocessing/image/utils.py
imports: import io
  import os
  import warnings
  from pathlib import Path
  import numpy
label_desc: Use image node_id 3 for calling a global function with example usage: load_img(path, grayscale, color_mode, target_size, interpolation, keep_aspect_ratio) and returns: img