code: def _compute_tiles(
      imgs: torch.Tensor,
      grid_size: Tuple[int, int],
      even_tile_size: bool = False,
  ) -> Tuple[torch.Tensor, torch.Tensor]:
      r"""Compute tiles on an image according to a grid size.
  
      Note that padding can be added to the image in order to crop properly the image.
      So, the grid_size (GH, GW) x tile_size (TH, TW) >= image_size (H, W)
  
      Args:
          imgs: batch of 2D images with shape (B, C, H, W) or (C, H, W).
          grid_size: number of tiles to be cropped in each direction (GH, GW)
          even_tile_size: Determine if the width and height of the tiles must be even.
  
      Returns:
          tensor with tiles (B, GH, GW, C, TH, TW). B = 1 in case of a single image is provided.
          tensor with the padded batch of 2D imageswith shape (B, C, H', W').
      """
      batch: torch.Tensor = imgs  # B x C x H x W
  
      # compute stride and kernel size
      h, w = batch.shape[-2:]
      kernel_vert: int = math.ceil(h / grid_size[0])
      kernel_horz: int = math.ceil(w / grid_size[1])
  
      if even_tile_size:
          kernel_vert += 1 if kernel_vert % 2 else 0
          kernel_horz += 1 if kernel_horz % 2 else 0
  
      # add padding (with that kernel size we could need some extra cols and rows...)
      pad_vert = kernel_vert * grid_size[0] - h
      pad_horz = kernel_horz * grid_size[1] - w
  
      # add the padding in the last coluns and rows
      if pad_vert > batch.shape[-2] or pad_horz > batch.shape[-1]:
          raise ValueError(
              "Cannot compute tiles on the image according to the given grid size"
          )
  
      if pad_vert > 0 or pad_horz > 0:
          batch = F.pad(
              batch, [0, pad_horz, 0, pad_vert], mode="reflect"
          )  # B x C x H' x W'
  
      # compute tiles
      c: int = batch.shape[-3]
      tiles: torch.Tensor = (
          batch.unfold(1, c, c)  # unfold(dimension, size, step)
          .unfold(2, kernel_vert, kernel_vert)
          .unfold(3, kernel_horz, kernel_horz)
          .squeeze(1)
      ).contiguous()  # GH x GW x C x TH x TW
  
      if tiles.shape[-5] != grid_size[0]:
          raise AssertionError
  
      if tiles.shape[-4] != grid_size[1]:
          raise AssertionError
  
      return tiles, batch
  
file_path: kornia/kornia/enhance/equalization.py
imports: import math
  from typing import Tuple
  import torch
  import torch.nn.functional
  from kornia.utils.helpers import _torch_histc_cast
  from kornia.utils.image import perform_keep_shape_image
  from .histogram import histogram
label_desc: Use image node_id 1 for calling a global function with example usage: _compute_tiles(imgs, grid_size, even_tile_size) and returns: tiles,  batch