code: def edge_aware_blur_pool2d(
      input: Tensor,
      kernel_size: tuple[int, int] | int,
      edge_threshold: float = 1.25,
      edge_dilation_kernel_size: int = 3,
      epsilon: float = 1e-6,
  ) -> Tensor:
      r"""Blur the input tensor while maintaining its edges.
  
      Args:
          input: the input image to blur with shape :math:`(B, C, H, W)`.
          kernel_size: the kernel size for max pooling.
          edge_threshold: positive threshold for the edge decision rule; edge/non-edge.
          edge_dilation_kernel_size: the kernel size for dilating the edges.
          epsilon: for numerical stability.
  
      Returns:
          The blurred tensor of shape :math:`(B, C, H, W)`.
      """
      KORNIA_CHECK_SHAPE(input, ["B", "C", "H", "W"])
      KORNIA_CHECK(
          edge_threshold > 0.0,
          f"edge threshold should be positive, but got '{edge_threshold}'",
      )
  
      input = pad(
          input, (2, 2, 2, 2), mode="reflect"
      )  # pad to avoid artifacts near physical edges
      blurred_input = blur_pool2d(
          input, kernel_size=kernel_size, stride=1
      )  # blurry version of the input
  
      # calculate the edges (add epsilon to avoid taking the log of 0)
      log_input, log_thresh = (input + epsilon).log2(), (
          tensor(edge_threshold)
      ).log2()
      edges_x = log_input[..., :, 4:] - log_input[..., :, :-4]
      edges_y = log_input[..., 4:, :] - log_input[..., :-4, :]
      edges_x, edges_y = edges_x.mean(
          dim=-3, keepdim=True
      ), edges_y.mean(dim=-3, keepdim=True)
      edges_x_mask, edges_y_mask = edges_x.abs() > log_thresh.to(
          edges_x
      ), edges_y.abs() > log_thresh.to(edges_y)
      edges_xy_mask = (
          edges_x_mask[..., 2:-2, :] + edges_y_mask[..., :, 2:-2]
      ).type_as(input)
  
      # dilate the content edges to have a soft mask of edges
      dilated_edges = F.max_pool3d(
          edges_xy_mask,
          edge_dilation_kernel_size,
          1,
          edge_dilation_kernel_size // 2,
      )
  
      # slice the padded regions
      input = input[..., 2:-2, 2:-2]
      blurred_input = blurred_input[..., 2:-2, 2:-2]
  
      # fuse the input image on edges and blurry input everywhere else
      blurred = (
          dilated_edges * input + (1.0 - dilated_edges) * blurred_input
      )
  
      return blurred
  
imports: from __future__ import annotations
  import torch.nn.functional
  from kornia.core import Module, Tensor, as_tensor, pad, tensor
  from kornia.core.check import KORNIA_CHECK, KORNIA_CHECK_SHAPE
  from .kernels import get_pascal_kernel_2d
  from .median import _compute_zero_padding
label_desc: Use image node_id 5 for calling a global function with example usage: edge_aware_blur_pool2d(input, kernel_size, edge_threshold, edge_dilation_kernel_size, epsilon) and returns: blurred