code: def spatial_gradient3d(
      input: Tensor, mode: str = "diff", order: int = 1
  ) -> Tensor:
      r"""Compute the first and second order volume derivative in x, y and d using a diff operator.
  
      Args:
          input: input features tensor with shape :math:`(B, C, D, H, W)`.
          mode: derivatives modality, can be: `sobel` or `diff`.
          order: the order of the derivatives.
  
      Return:
          the spatial gradients of the input feature map with shape math:`(B, C, 3, D, H, W)`
          or :math:`(B, C, 6, D, H, W)`.
  
      Examples:
          >>> input = torch.rand(1, 4, 2, 4, 4)
          >>> output = spatial_gradient3d(input)
          >>> output.shape
          torch.Size([1, 4, 3, 2, 4, 4])
      """
      KORNIA_CHECK_IS_TENSOR(input)
      KORNIA_CHECK_SHAPE(input, ["B", "C", "D", "H", "W"])
  
      b, c, d, h, w = input.shape
      dev = input.device
      dtype = input.dtype
      if (mode == "diff") and (order == 1):
          # we go for the special case implementation due to conv3d bad speed
          x: Tensor = pad(input, 6 * [1], "replicate")
          center = slice(1, -1)
          left = slice(0, -2)
          right = slice(2, None)
          out = torch.empty(b, c, 3, d, h, w, device=dev, dtype=dtype)
          out[..., 0, :, :, :] = (
              x[..., center, center, right]
              - x[..., center, center, left]
          )
          out[..., 1, :, :, :] = (
              x[..., center, right, center]
              - x[..., center, left, center]
          )
          out[..., 2, :, :, :] = (
              x[..., right, center, center]
              - x[..., left, center, center]
          )
          out = 0.5 * out
      else:
          # prepare kernel
          # allocate kernel
          kernel = get_spatial_gradient_kernel3d(
              mode, order, device=dev, dtype=dtype
          )
  
          tmp_kernel = kernel.repeat(c, 1, 1, 1, 1)
  
          # convolve input tensor with grad kernel
          kernel_flip = tmp_kernel.flip(-3)
  
          # Pad with "replicate for spatial dims, but with zeros for channel
          spatial_pad = [
              kernel.size(2) // 2,
              kernel.size(2) // 2,
              kernel.size(3) // 2,
              kernel.size(3) // 2,
              kernel.size(4) // 2,
              kernel.size(4) // 2,
          ]
          out_ch: int = 6 if order == 2 else 3
          out = F.conv3d(
              pad(input, spatial_pad, "replicate"),
              kernel_flip,
              padding=0,
              groups=c,
          ).view(b, c, out_ch, d, h, w)
      return out
  
imports: from __future__ import annotations
  import torch
  import torch.nn.functional
  from kornia.core import Module, Tensor, pad
  from kornia.core.check import KORNIA_CHECK_IS_TENSOR, KORNIA_CHECK_SHAPE
  from .kernels import get_spatial_gradient_kernel2d, get_spatial_gradient_kernel3d, normalize_kernel2d
label_desc: Use image node_id 2 for calling a global function with example usage: spatial_gradient3d(input, mode, order) and returns: out