code: def local_response_norm(
      x: Union[ivy.NativeArray, ivy.Array],
      size,
      /,
      *,
      bias: Optional[float] = 1.0,
      alpha: Optional[float] = 1.0,
      beta: Optional[float] = 0.5,
      average: bool = False,
      data_format: Optional[Literal["NHWC", "NCHW"]] = "NHWC",
      out: Optional[Tuple[ivy.Array, ivy.Array, ivy.Array]] = None,
  ) -> ivy.Array:
      """Apply local response normalization across the channels of a 4D input
      array. The 4-D array is treated as a 3-D array of 1-D vectors (along the
      channel dimension), and each vector is normalized independently. Within a
      given vector, each component is divided by the squared sum of the
      neighbouring components.
  
      Parameters
      ----------
      x
          Input array of default shape (N, H, W, C), where N is the batch dimension,
          H and W correspond to the spatial dimensions and C corresponds to the
          channel dimension.
      size
          The width of the normalization window.
      alpha
          The multiplicative factor.
      beta
          The exponent.
      bias
          An additive factor.
      average
          If True, each component is divided by the **averaged** squared sum.
      data_format
          The ordering of the dimensions in the input, either "NHWC" or "NCHW".
      out
          optional output arrays, for writing the result to.
  
      Returns
      -------
      ret
          The normalized array.
      """
      if data_format == "NHWC":
          x = ivy.permute_dims(x, axes=(0, 3, 1, 2))
      x_shape = x.shape
      alpha = alpha * size if not average else alpha
      ret = ivy.square(x)
      ret = ivy.reshape(
          ret, (x_shape[0], 1, x_shape[1], x_shape[2], -1)
      )
      ret = ivy.zero_pad(
          ret,
          (
              (0, 0),
              (0, 0),
              (size // 2, (size - 1) // 2),
              (0, 0),
              (0, 0),
          ),
      )
      ret = ivy.avg_pool3d(
          ret,
          (size, 1, 1),
          1,
          "VALID",
          count_include_pad=True,
          data_format="NCDHW",
      )
      ret = ivy.squeeze(ret, axis=1)
      ret = ivy.reshape(ret, x_shape)
      ret = ivy.pow(ivy.add(ivy.multiply(ret, alpha), bias), beta)
      ret = ivy.divide(x, ret)
      if data_format == "NHWC":
          ret = ivy.permute_dims(ret, axes=(0, 2, 3, 1))
      return ret
  
file_path: ivy/ivy/functional/ivy/experimental/norms.py
imports: from typing import Literal, Union, Optional, Tuple
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_partial_mixed_function, to_native_arrays_and_back, handle_out_argument, handle_nestable, handle_array_like_without_promotion, inputs_to_ivy_arrays, handle_array_function, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 3 for calling a global function with example usage: local_response_norm() and returns: ret