class_docstr: Compute pools and blurs and downsample a given feature map.
  
  Equivalent to ```nn.Sequential(nn.MaxPool2d(...), BlurPool2D(...))```
  
  See :cite:`zhang2019shiftinvar` for more details.
  
  Args:
      kernel_size: the kernel size for max pooling.
      stride: stride for pooling.
      max_pool_size: the kernel size for max pooling.
      ceil_mode: should be true to match output size of conv2d with same kernel size.
  
  Shape:
      - Input: :math:`(B, C, H, W)`
      - Output: :math:`(B, C, H / stride, W / stride)`
  
  Returns:
      torch.Tensor: the transformed tensor.
  
  Examples:
      >>> import torch.nn as nn
      >>> from kornia.filters.blur_pool import BlurPool2D
      >>> input = torch.eye(5)[None, None]
      >>> mbp = MaxBlurPool2D(kernel_size=3, stride=2, max_pool_size=2, ceil_mode=False)
      >>> mbp(input)
      tensor([[[[0.5625, 0.3125],
                [0.3125, 0.8750]]]])
      >>> seq = nn.Sequential(nn.MaxPool2d(kernel_size=2, stride=1), BlurPool2D(kernel_size=3, stride=2))
      >>> seq(input)
      tensor([[[[0.5625, 0.3125],
                [0.3125, 0.8750]]]])
code: def __init__(
      self,
      kernel_size: tuple[int, int] | int,
      stride: int = 2,
      max_pool_size: int = 2,
      ceil_mode: bool = False,
  ) -> None:
      super().__init__()
      self.kernel_size = kernel_size
      self.stride = stride
      self.max_pool_size = max_pool_size
      self.ceil_mode = ceil_mode
      self.kernel = get_pascal_kernel_2d(kernel_size, norm=True)
  
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 1 to create a new MaxBlurPool2D object from inherited base classes: Module with example: obj = MaxBlurPool2D(kernel_size, stride, max_pool_size, ceil_mode)