code: def create_image_augment(
      data_shape,
      resize=0,
      rand_crop=False,
      rand_resize=False,
      rand_mirror=False,
      mean=None,
      std=None,
      brightness=0,
      contrast=0,
      saturation=0,
      hue=0,
      pca_noise=0,
      rand_gray=0,
      inter_method=2,
      dtype="float32",
  ):
      """Creates an augmenter block.
  
      Parameters
      ----------
      data_shape : tuple of int
          Shape for output data
      resize : int
          Resize shorter edge if larger than 0 at the begining
      rand_crop : bool
          Whether to enable random cropping other than center crop
      rand_resize : bool
          Whether to enable random sized cropping, require rand_crop to be enabled
      rand_gray : float
          [0, 1], probability to convert to grayscale for all channels, the number
          of channels will not be reduced to 1
      rand_mirror : bool
          Whether to apply horizontal flip to image with probability 0.5
      mean : np.ndarray or None
          Mean pixel values for [r, g, b]
      std : np.ndarray or None
          Standard deviations for [r, g, b]
      brightness : float
          Brightness jittering range (percent)
      contrast : float
          Contrast jittering range (percent)
      saturation : float
          Saturation jittering range (percent)
      hue : float
          Hue jittering range (percent)
      pca_noise : float
          Pca noise level (percent)
      inter_method : int, default=2(Area-based)
          Interpolation method for all resizing operations
  
          Possible values:
          0: Nearest Neighbors Interpolation.
          1: Bilinear interpolation.
          2: Bicubic interpolation over 4x4 pixel neighborhood.
          3: Area-based (resampling using pixel area relation). It may be a
          preferred method for image decimation, as it gives moire-free
          results. But when the image is zoomed, it is similar to the Nearest
          Neighbors method. (used by default).
          4: Lanczos interpolation over 8x8 pixel neighborhood.
          10: Random select from interpolation method metioned above.
          Note:
          When shrinking an image, it will generally look best with AREA-based
          interpolation, whereas, when enlarging an image, it will generally look best
          with Bicubic (slow) or Bilinear (faster but still looks OK).
  
      Examples
      --------
      >>> # An example of creating multiple augmenters
      >>> augs = mx.gluon.contrib.data.create_image_augment(data_shape=(3, 300, 300), rand_mirror=True,
      ...    mean=True, brightness=0.125, contrast=0.125, rand_gray=0.05,
      ...    saturation=0.125, pca_noise=0.05, inter_method=10)
      """
      if inter_method == 10:
          inter_method = np.random.randint(0, 5)
      augmenter = HybridSequential()
      if resize > 0:
          augmenter.add(
              transforms.image.Resize(
                  resize, interpolation=inter_method
              )
          )
      crop_size = (data_shape[2], data_shape[1])
      if rand_resize:
          assert rand_crop
          augmenter.add(
              transforms.image.RandomResizedCrop(
                  crop_size, interpolation=inter_method
              )
          )
      elif rand_crop:
          augmenter.add(
              transforms.image.RandomCrop(
                  crop_size, interpolation=inter_method
              )
          )
      else:
          augmenter.add(
              transforms.image.CenterCrop(
                  crop_size, interpolation=inter_method
              )
          )
  
      if rand_mirror:
          augmenter.add(transforms.image.RandomFlipLeftRight(0.5))
  
      augmenter.add(transforms.Cast())
  
      if brightness or contrast or saturation or hue:
          augmenter.add(
              transforms.image.RandomColorJitter(
                  brightness, contrast, saturation, hue
              )
          )
  
      if pca_noise > 0:
          augmenter.add(transforms.image.RandomLighting(pca_noise))
  
      if rand_gray > 0:
          augmenter.add(transforms.image.RandomGray(rand_gray))
  
      if mean is True:
          mean = [123.68, 116.28, 103.53]
      elif mean is not None:
          assert isinstance(mean, (tuple, list))
  
      if std is True:
          std = [58.395, 57.12, 57.375]
      elif std is not None:
          assert isinstance(std, (tuple, list))
  
      augmenter.add(transforms.image.ToTensor())
  
      if mean is not None or std is not None:
          augmenter.add(transforms.image.Normalize(mean, std))
  
      augmenter.add(transforms.Cast(dtype))
  
      return augmenter
  
imports: import logging
  import numpy
  from .....None import ndarray
  from .....util import is_np_array
  from .....None import numpy
  from ....nn import HybridSequential, Sequential, HybridBlock, Block
  from ....data.vision import transforms
  from ....data import DataLoader
  from .transforms import bbox
label_desc: Use image node_id 1 for calling a global function with example usage: create_image_augment(data_shape, resize, rand_crop, rand_resize, rand_mirror, mean, std, brightness, contrast, saturation, hue, pca_noise, rand_gray, inter_method, dtype) and returns: augmenter