code: def normalize(
      image: np.ndarray,
      mean: Union[float, Iterable[float]],
      std: Union[float, Iterable[float]],
      data_format: Optional[ChannelDimension] = None,
      input_data_format: Optional[Union[str, ChannelDimension]] = None,
  ) -> np.ndarray:
      """
      Normalizes `image` using the mean and standard deviation specified by `mean` and `std`.
  
      image = (image - mean) / std
  
      Args:
          image (`np.ndarray`):
              The image to normalize.
          mean (`float` or `Iterable[float]`):
              The mean to use for normalization.
          std (`float` or `Iterable[float]`):
              The standard deviation to use for normalization.
          data_format (`ChannelDimension`, *optional*):
              The channel dimension format of the output image. If unset, will use the inferred format from the input.
          input_data_format (`ChannelDimension`, *optional*):
              The channel dimension format of the input image. If unset, will use the inferred format from the input.
      """
      if not isinstance(image, np.ndarray):
          raise ValueError("image must be a numpy array")
  
      if input_data_format is None:
          input_data_format = infer_channel_dimension_format(image)
      channel_axis = get_channel_dimension_axis(
          image, input_data_format=input_data_format
      )
      num_channels = image.shape[channel_axis]
  
      # We cast to float32 to avoid errors that can occur when subtracting uint8 values.
      # We preserve the original dtype if it is a float type to prevent upcasting float16.
      if not np.issubdtype(image.dtype, np.floating):
          image = image.astype(np.float32)
  
      if isinstance(mean, Iterable):
          if len(mean) != num_channels:
              raise ValueError(
                  f"mean must have {num_channels} elements if it is an iterable, got {len(mean)}"
              )
      else:
          mean = [mean] * num_channels
      mean = np.array(mean, dtype=image.dtype)
  
      if isinstance(std, Iterable):
          if len(std) != num_channels:
              raise ValueError(
                  f"std must have {num_channels} elements if it is an iterable, got {len(std)}"
              )
      else:
          std = [std] * num_channels
      std = np.array(std, dtype=image.dtype)
  
      if input_data_format == ChannelDimension.LAST:
          image = (image - mean) / std
      else:
          image = ((image.T - mean) / std).T
  
      image = (
          to_channel_dimension_format(
              image, data_format, input_data_format
          )
          if data_format is not None
          else image
      )
      return 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 7 for calling a global function with example usage: normalize(image, mean, std, data_format, input_data_format) and returns: image