code: def conv_downsample_2d(x, w, k=None, factor=2, gain=1):
      """Fused `tf.nn.conv2d()` followed by `downsample_2d()`.
  
      Padding is performed only once at the beginning, not between the operations.
      The fused op is considerably more efficient than performing the same
      calculation
      using standard TensorFlow ops. It supports gradients of arbitrary order.
      Args:
          x:            Input tensor of the shape `[N, C, H, W]` or `[N, H, W,
            C]`.
          w:            Weight tensor of the shape `[filterH, filterW, inChannels,
            outChannels]`. Grouped convolution can be performed by `inChannels =
            x.shape[0] // numGroups`.
          k:            FIR filter of the shape `[firH, firW]` or `[firN]`
            (separable). The default is `[1] * factor`, which corresponds to
            average pooling.
          factor:       Integer downsampling factor (default: 2).
          gain:         Scaling factor for signal magnitude (default: 1.0).
  
      Returns:
          Tensor of the shape `[N, C, H // factor, W // factor]` or
          `[N, H // factor, W // factor, C]`, and same datatype as `x`.
      """
  
      assert isinstance(factor, int) and factor >= 1
      _outC, _inC, convH, convW = w.shape
      assert convW == convH
      if k is None:
          k = [1] * factor
      k = _setup_kernel(k) * gain
      p = (k.shape[0] - factor) + (convW - 1)
      s = [factor, factor]
      x = upfirdn2d(
          x,
          torch.tensor(k, device=x.device),
          pad=((p + 1) // 2, p // 2),
      )
      return F.conv2d(x, w, stride=s, padding=0)
  
file_path: espnet/espnet2/enh/layers/ncsnpp_utils/up_or_down_sampling.py
imports: import numpy
  import torch
  import torch.nn
  import torch.nn.functional
  from espnet2.enh.layers.ncsnpp_utils.upfirdn2d import upfirdn2d
label_desc: Use image node_id 5 for calling a global function with example usage: conv_downsample_2d(x, w, k, factor, gain) and returns: F