code: def _map_luts(
      interp_tiles: torch.Tensor, luts: torch.Tensor
  ) -> torch.Tensor:
      r"""Assign the required luts to each tile.
  
      Args:
          interp_tiles: set of interpolation tiles. (B, 2GH, 2GW, C, TH/2, TW/2)
          luts: luts for each one of the original tiles. (B, GH, GW, C, 256)
  
      Returns:
           mapped luts (B, 2GH, 2GW, 4, C, 256)
      """
      if interp_tiles.dim() != 6:
          raise AssertionError("interp_tiles tensor must be 6D.")
  
      if luts.dim() != 5:
          raise AssertionError("luts tensor must be 5D.")
  
      # gh, gw -> 2x the number of tiles used to compute the histograms
      # th, tw -> /2 the sizes of the tiles used to compute the histograms
      num_imgs, gh, gw, c, _, _ = interp_tiles.shape
  
      # precompute idxs for non corner regions (doing it in cpu seems slightly faster)
      j_idxs = torch.empty(0, 4, dtype=torch.long)
      if gh > 2:
          j_floor = (
              torch.arange(1, gh - 1)
              .view(gh - 2, 1)
              .div(2, rounding_mode="trunc")
          )
          j_idxs = torch.tensor(
              [[0, 0, 1, 1], [-1, -1, 0, 0]] * ((gh - 2) // 2)
          )  # reminder + j_idxs[:, 0:2] -= 1
          j_idxs += j_floor
  
      i_idxs = torch.empty(0, 4, dtype=torch.long)
      if gw > 2:
          i_floor = (
              torch.arange(1, gw - 1)
              .view(gw - 2, 1)
              .div(2, rounding_mode="trunc")
          )
          i_idxs = torch.tensor(
              [[0, 1, 0, 1], [-1, 0, -1, 0]] * ((gw - 2) // 2)
          )  # reminder + i_idxs[:, [0, 2]] -= 1
          i_idxs += i_floor
  
      # selection of luts to interpolate each patch
      # create a tensor with dims: interp_patches height and width x 4 x num channels x bins in the histograms
      # the tensor is init to -1 to denote non init hists
      luts_x_interp_tiles: torch.Tensor = (
          torch.full(  # B x GH x GW x 4 x C x 256
              (num_imgs, gh, gw, 4, c, luts.shape[-1]),
              -1,
              dtype=interp_tiles.dtype,
              device=interp_tiles.device,
          )
      )
      # corner regions
      luts_x_interp_tiles[:, 0 :: gh - 1, 0 :: gw - 1, 0] = luts[
          :, 0 :: max(gh // 2 - 1, 1), 0 :: max(gw // 2 - 1, 1)
      ]
      # border region (h)
      luts_x_interp_tiles[:, 1:-1, 0 :: gw - 1, 0] = luts[
          :, j_idxs[:, 0], 0 :: max(gw // 2 - 1, 1)
      ]
      luts_x_interp_tiles[:, 1:-1, 0 :: gw - 1, 1] = luts[
          :, j_idxs[:, 2], 0 :: max(gw // 2 - 1, 1)
      ]
      # border region (w)
      luts_x_interp_tiles[:, 0 :: gh - 1, 1:-1, 0] = luts[
          :, 0 :: max(gh // 2 - 1, 1), i_idxs[:, 0]
      ]
      luts_x_interp_tiles[:, 0 :: gh - 1, 1:-1, 1] = luts[
          :, 0 :: max(gh // 2 - 1, 1), i_idxs[:, 1]
      ]
      # internal region
      luts_x_interp_tiles[:, 1:-1, 1:-1, :] = luts[
          :,
          j_idxs.repeat(max(gh - 2, 1), 1, 1).permute(1, 0, 2),
          i_idxs.repeat(max(gw - 2, 1), 1, 1),
      ]
  
      return luts_x_interp_tiles
  
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 5 for calling a global function with example usage: _map_luts(interp_tiles, luts) and returns: luts_x_interp_tiles