code: def _guided_blur_multichannel_guidance(
      guidance: Tensor,
      input: Tensor,
      kernel_size: tuple[int, int] | int,
      eps: float | Tensor,
      border_type: str = "reflect",
      subsample: int = 1,
  ) -> Tensor:
      (
          guidance_sub,
          input_sub,
          kernel_size,
      ) = _preprocess_fast_guided_blur(
          guidance, input, kernel_size, subsample
      )
      B, C, H, W = guidance_sub.shape
  
      mean_I = box_blur(guidance_sub, kernel_size, border_type).permute(
          0, 2, 3, 1
      )
      II = (
          guidance_sub.unsqueeze(1) * guidance_sub.unsqueeze(2)
      ).flatten(1, 2)
      corr_I = box_blur(II, kernel_size, border_type).permute(
          0, 2, 3, 1
      )
      var_I = corr_I.reshape(B, H, W, C, C) - mean_I.unsqueeze(
          -2
      ) * mean_I.unsqueeze(-1)
  
      if guidance is input:
          mean_p = mean_I
          cov_Ip = var_I
  
      else:
          mean_p = box_blur(
              input_sub, kernel_size, border_type
          ).permute(0, 2, 3, 1)
          Ip = (
              input_sub.unsqueeze(1) * guidance_sub.unsqueeze(2)
          ).flatten(1, 2)
          corr_Ip = box_blur(Ip, kernel_size, border_type).permute(
              0, 2, 3, 1
          )
          cov_Ip = corr_Ip.reshape(B, H, W, C, -1) - mean_p.unsqueeze(
              -2
          ) * mean_I.unsqueeze(-1)
  
      if isinstance(eps, Tensor):
          _eps = torch.eye(
              C, device=guidance.device, dtype=guidance.dtype
          ).view(1, 1, 1, C, C) * eps.view(-1, 1, 1, 1, 1)
      else:
          _eps = guidance.new_full((C,), eps).diag().view(1, 1, 1, C, C)
      a = torch.linalg.solve(
          var_I + _eps, cov_Ip
      )  # B, H, W, C_guidance, C_input
      b = mean_p - (mean_I.unsqueeze(-2) @ a).squeeze(
          -2
      )  # B, H, W, C_input
  
      mean_a = box_blur(
          a.flatten(-2).permute(0, 3, 1, 2), kernel_size, border_type
      )
      mean_b = box_blur(b.permute(0, 3, 1, 2), kernel_size, border_type)
  
      if subsample > 1:
          mean_a = interpolate(
              mean_a, scale_factor=subsample, mode="bilinear"
          )
          mean_b = interpolate(
              mean_b, scale_factor=subsample, mode="bilinear"
          )
      mean_a = mean_a.view(B, C, -1, H * subsample, W * subsample)
  
      # einsum might not be contiguous, thus mean_b is the first argument
      return mean_b + torch.einsum("BCHW,BCcHW->BcHW", guidance, mean_a)
  
file_path: kornia/kornia/filters/guided.py
imports: from __future__ import annotations
  import torch
  from torch.nn.functional import interpolate
  from kornia.core import Module, Tensor
  from kornia.core.check import KORNIA_CHECK, KORNIA_CHECK_IS_TENSOR, KORNIA_CHECK_SHAPE
  from .blur import box_blur
  from .kernels import _unpack_2d_ks
label_desc: Use image node_id 3 for calling a global function with example usage: _guided_blur_multichannel_guidance(guidance, input, kernel_size, eps, border_type, subsample) and returns: unknown