code: def _compute_equalized_tiles(
      interp_tiles: torch.Tensor, luts: torch.Tensor
  ) -> torch.Tensor:
      r"""Equalize the tiles.
  
      Args:
          interp_tiles: set of interpolation tiles, values must be in the range [0, 1].
            (B, 2GH, 2GW, C, TH/2, TW/2)
          luts: luts for each one of the original tiles. (B, GH, GW, C, 256)
  
      Returns:
          equalized tiles (B, 2GH, 2GW, C, TH/2, TW/2)
      """
      if interp_tiles.dim() != 6:
          raise AssertionError("interp_tiles tensor must be 6D.")
  
      if luts.dim() != 5:
          raise AssertionError("luts tensor must be 5D.")
  
      mapped_luts: torch.Tensor = _map_luts(
          interp_tiles, luts
      )  # Bx2GHx2GWx4xCx256
  
      # 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, th, tw = interp_tiles.shape
  
      # equalize tiles
      flatten_interp_tiles: torch.Tensor = (
          (interp_tiles * 255).long().flatten(-2, -1)
      )  # B x GH x GW x 4 x C x (THxTW)
      flatten_interp_tiles = flatten_interp_tiles.unsqueeze(-3).expand(
          num_imgs, gh, gw, 4, c, th * tw
      )
      preinterp_tiles_equalized = (
          torch.gather(
              mapped_luts, 5, flatten_interp_tiles
          )  # B x GH x GW x 4 x C x TH x TW
          .to(interp_tiles)
          .reshape(num_imgs, gh, gw, 4, c, th, tw)
      )
  
      # interp tiles
      tiles_equalized: torch.Tensor = torch.zeros_like(interp_tiles)
  
      # compute the interpolation weights (shapes are 2 x TH x TW because they must be applied to 2 interp tiles)
      ih = (
          torch.arange(
              2 * th - 1,
              -1,
              -1,
              dtype=interp_tiles.dtype,
              device=interp_tiles.device,
          )
          .div(2.0 * th - 1)[None]
          .transpose(-2, -1)
          .expand(2 * th, tw)
      )
      ih = ih.unfold(0, th, th).unfold(1, tw, tw)  # 2 x 1 x TH x TW
      iw = (
          torch.arange(
              2 * tw - 1,
              -1,
              -1,
              dtype=interp_tiles.dtype,
              device=interp_tiles.device,
          )
          .div(2.0 * tw - 1)
          .expand(th, 2 * tw)
      )
      iw = iw.unfold(0, th, th).unfold(1, tw, tw)  # 1 x 2 x TH x TW
  
      # compute row and column interpolation weights
      tiw = (
          iw.expand((gw - 2) // 2, 2, th, tw)
          .reshape(gw - 2, 1, th, tw)
          .unsqueeze(0)
      )  # 1 x GW-2 x 1 x TH x TW
      tih = ih.repeat((gh - 2) // 2, 1, 1, 1).unsqueeze(
          1
      )  # GH-2 x 1 x 1 x TH x TW
  
      # internal regions
      tl, tr, bl, br = preinterp_tiles_equalized[:, 1:-1, 1:-1].unbind(
          3
      )
      t = torch.addcmul(tr, tiw, torch.sub(tl, tr))
      b = torch.addcmul(br, tiw, torch.sub(bl, br))
      tiles_equalized[:, 1:-1, 1:-1] = torch.addcmul(
          b, tih, torch.sub(t, b)
      )
  
      # corner regions
      tiles_equalized[
          :, 0 :: gh - 1, 0 :: gw - 1
      ] = preinterp_tiles_equalized[:, 0 :: gh - 1, 0 :: gw - 1, 0]
  
      # border region (h)
      t, b, _, _ = preinterp_tiles_equalized[:, 1:-1, 0].unbind(2)
      tiles_equalized[:, 1:-1, 0] = torch.addcmul(
          b, tih.squeeze(1), torch.sub(t, b)
      )
      t, b, _, _ = preinterp_tiles_equalized[:, 1:-1, gh - 1].unbind(2)
      tiles_equalized[:, 1:-1, gh - 1] = torch.addcmul(
          b, tih.squeeze(1), torch.sub(t, b)
      )
  
      # border region (w)
      left, right, _, _ = preinterp_tiles_equalized[:, 0, 1:-1].unbind(
          2
      )
      tiles_equalized[:, 0, 1:-1] = torch.addcmul(
          right, tiw, torch.sub(left, right)
      )
      left, right, _, _ = preinterp_tiles_equalized[
          :, gw - 1, 1:-1
      ].unbind(2)
      tiles_equalized[:, gw - 1, 1:-1] = torch.addcmul(
          right, tiw, torch.sub(left, right)
      )
  
      # same type as the input
      return tiles_equalized.div(255.0)
  
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 6 for calling a global function with example usage: _compute_equalized_tiles(interp_tiles, luts) and returns: tiles_equalized