code: def rotate(
      images: TensorLike,
      angles: TensorLike,
      interpolation: str = "nearest",
      fill_mode: str = "constant",
      name: Optional[str] = None,
      fill_value: TensorLike = 0.0,
  ) -> tf.Tensor:
      """Rotate image(s) counterclockwise by the passed angle(s) in radians.
  
      Args:
        images: A tensor of shape
          `(num_images, num_rows, num_columns, num_channels)`
          (NHWC), `(num_rows, num_columns, num_channels)` (HWC), or
          `(num_rows, num_columns)` (HW).
        angles: A scalar angle to rotate all images by, or (if `images` has rank 4)
          a vector of length num_images, with an angle for each image in the
          batch.
        interpolation: Interpolation mode. Supported values: "nearest",
          "bilinear".
        fill_mode: Points outside the boundaries of the input are filled according
          to the given mode (one of `{'constant', 'reflect', 'wrap', 'nearest'}`).
          - *reflect*: `(d c b a | a b c d | d c b a)`
            The input is extended by reflecting about the edge of the last pixel.
          - *constant*: `(k k k k | a b c d | k k k k)`
            The input is extended by filling all values beyond the edge with the
            same constant value k = 0.
          - *wrap*: `(a b c d | a b c d | a b c d)`
            The input is extended by wrapping around to the opposite edge.
          - *nearest*: `(a a a a | a b c d | d d d d)`
            The input is extended by the nearest pixel.
        fill_value: a float represents the value to be filled outside the
          boundaries when `fill_mode` is "constant".
        name: The name of the op.
  
      Returns:
        Image(s) with the same type and shape as `images`, rotated by the given
        angle(s). Empty space due to the rotation will be filled with zeros.
  
      Raises:
        TypeError: If `images` is an invalid type.
      """
      with tf.name_scope(name or "rotate"):
          image_or_images = tf.convert_to_tensor(images)
          if image_or_images.dtype.base_dtype not in _IMAGE_DTYPES:
              raise TypeError(
                  "Invalid dtype %s." % image_or_images.dtype
              )
          images = img_utils.to_4D_image(image_or_images)
          original_ndims = img_utils.get_ndims(image_or_images)
  
          image_height = tf.cast(
              tf.shape(images)[1], tf.dtypes.float32
          )[None]
          image_width = tf.cast(tf.shape(images)[2], tf.dtypes.float32)[
              None
          ]
          output = transform(
              images,
              angles_to_projective_transforms(
                  angles, image_height, image_width
              ),
              interpolation=interpolation,
              fill_mode=fill_mode,
              fill_value=fill_value,
          )
          return img_utils.from_4D_image(output, original_ndims)
  
file_path: addons/tensorflow_addons/image/transform_ops.py
imports: import tensorflow
  from tensorflow_addons.image import utils
  from tensorflow_addons.utils.types import TensorLike
  from tensorflow_addons.image.utils import wrap, unwrap
  from typing import Optional
label_desc: Use image node_id 6 for calling a global function with example usage: rotate(images, angles, interpolation, fill_mode, name, fill_value) and returns: img_utils