code: def mean_filter2d(
      image: TensorLike,
      filter_shape: Union[int, Iterable[int]] = (3, 3),
      padding: str = "REFLECT",
      constant_values: TensorLike = 0,
      name: Optional[str] = None,
  ) -> tf.Tensor:
      """Perform mean filtering on image(s).
  
      Args:
        image: Either a 2-D `Tensor` of shape `[height, width]`,
          a 3-D `Tensor` of shape `[height, width, channels]`,
          or a 4-D `Tensor` of shape `[batch_size, height, width, channels]`.
        filter_shape: An `integer` or `tuple`/`list` of 2 integers, specifying
          the height and width of the 2-D mean filter. Can be a single integer
          to specify the same value for all spatial dimensions.
        padding: A `string`, one of "REFLECT", "CONSTANT", or "SYMMETRIC".
          The type of padding algorithm to use, which is compatible with
          `mode` argument in `tf.pad`. For more details, please refer to
          https://www.tensorflow.org/api_docs/python/tf/pad.
        constant_values: A `scalar`, the pad value to use in "CONSTANT"
          padding mode.
        name: A name for this operation (optional).
      Returns:
        2-D, 3-D or 4-D `Tensor` of the same dtype as input.
      Raises:
        ValueError: If `image` is not 2, 3 or 4-dimensional,
          if `padding` is other than "REFLECT", "CONSTANT" or "SYMMETRIC",
          or if `filter_shape` is invalid.
      """
      with tf.name_scope(name or "mean_filter2d"):
          image = tf.convert_to_tensor(image, name="image")
          original_ndims = img_utils.get_ndims(image)
          image = img_utils.to_4D_image(image)
  
          filter_shape = keras_utils.normalize_tuple(
              filter_shape, 2, "filter_shape"
          )
  
          # Keep the precision if it's float;
          # otherwise, convert to float32 for computing.
          orig_dtype = image.dtype
          if not image.dtype.is_floating:
              image = tf.dtypes.cast(image, tf.dtypes.float32)
  
          # Explicitly pad the image
          image = _pad(
              image,
              filter_shape,
              mode=padding,
              constant_values=constant_values,
          )
  
          # Filter of shape (filter_width, filter_height, in_channels, 1)
          # has the value of 1 for each element.
          area = tf.constant(
              filter_shape[0] * filter_shape[1], dtype=image.dtype
          )
          filter_shape += (tf.shape(image)[-1], 1)
          kernel = tf.ones(shape=filter_shape, dtype=image.dtype)
  
          output = tf.nn.depthwise_conv2d(
              image, kernel, strides=(1, 1, 1, 1), padding="VALID"
          )
  
          output /= area
  
          output = img_utils.from_4D_image(output, original_ndims)
          return tf.dtypes.cast(output, orig_dtype)
  
file_path: addons/tensorflow_addons/image/filters.py
imports: import tensorflow
  from tensorflow_addons.image import utils
  from tensorflow_addons.utils import keras_utils
  from tensorflow_addons.utils.types import TensorLike
  from typing import Optional, Union, List, Tuple, Iterable
label_desc: Use image node_id 2 for calling a global function with example usage: mean_filter2d(image, filter_shape, padding, constant_values, name) and returns: tf