code: def convolution(
      inp,
      outmaps,
      kernel,
      pad=None,
      stride=None,
      dilation=None,
      group=1,
      channel_last=False,
      w_init=None,
      b_init=None,
      base_axis=1,
      fix_parameters=False,
      rng=None,
      with_bias=True,
      apply_w=None,
      apply_b=None,
  ):
      """N-D Convolution with a bias term.
  
      For Dilated Convolution (a.k.a. Atrous Convolution), refer to:
  
      - Chen et al., DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs. https://arxiv.org/abs/1606.00915
  
      - Yu et al., Multi-Scale Context Aggregation by Dilated Convolutions. https://arxiv.org/abs/1511.07122
  
      Note:
  
          Convolution is a computationally intensive operation that
          should preferably be run with the `cudnn` backend. NNabla
          then uses CuDNN library functions to determine and cache the
          fastest algorithm for the given set of convolution parameters,
          which results in additional memory consumption which may pose
          a problem for GPUs with insufficient memory size. In that
          case, the `NNABLA_CUDNN_WORKSPACE_LIMIT` environment variable
          can be used to restrict the choice of algorithms to those that
          fit the given workspace memory limit, expressed in bytes. In
          some cases it may also be desired to restrict the automatic
          search to algorithms that produce deterministic (reproducible)
          results. This can be requested by setting the the environment
          variable `NNABLA_CUDNN_DETERMINISTIC` to a non-zero value.
  
      Args:
          inp (~nnabla.Variable): N-D array.
          outmaps (int): Number of convolution kernels (which is equal to the number of output channels). For example, to apply convolution on an input with 16 types of filters, specify 16.
          kernel (:obj:`tuple` of :obj:`int`): Convolution kernel size. For example, to apply convolution on an image with a 3 (height) by 5 (width) two-dimensional kernel, specify (3,5).
          pad (:obj:`tuple` of :obj:`int`): Padding sizes for dimensions.
          stride (:obj:`tuple` of :obj:`int`): Stride sizes for dimensions.
          dilation (:obj:`tuple` of :obj:`int`): Dilation sizes for dimensions.
          group (int): Number of groups of channels. This makes connections across channels more sparse by grouping connections along map direction.
          channel_last (bool): If True, the last dimension is considered as channel dimension, a.k.a. NHWC order.
          w_init (:obj:`nnabla.initializer.BaseInitializer` or :obj:`numpy.ndarray`): Initializer for weight. By default, it is initialized with :obj:`nnabla.initializer.UniformInitializer` within the range determined by :obj:`nnabla.initializer.calc_uniform_lim_glorot`.
          b_init (:obj:`nnabla.initializer.BaseInitializer` or :obj:`numpy.ndarray`): Initializer for bias. By default, it is initialized with zeros if `with_bias` is `True`.
          base_axis (int): Dimensions up to `base_axis` are treated as the sample dimensions.
          fix_parameters (bool): When set to `True`, the weights and biases will not be updated.
          rng (numpy.random.RandomState): Random generator for Initializer.
          with_bias (bool): Specify whether to include the bias term.
          apply_w (function): Lambda, function, or callable object applied to the weights.
          apply_b (function): Lambda, function, or callable object applied to the bias.
  
      Returns:
          :class:`~nnabla.Variable`: N-D array. See :obj:`~nnabla.functions.convolution` for the output shape.
  
      """
      if channel_last:
          channels = inp.shape[-1]
          filter_shape = tuple(kernel) + (channels // group,)
      else:
          channels = inp.shape[base_axis]
          filter_shape = (channels // group,) + tuple(kernel)
      if w_init is None:
          w_init = UniformInitializer(
              calc_uniform_lim_glorot(channels, outmaps, tuple(kernel)),
              rng=rng,
          )
      if with_bias and b_init is None:
          b_init = ConstantInitializer()
      w = get_parameter_or_create(
          "W",
          (outmaps,) + filter_shape,
          w_init,
          True,
          not fix_parameters,
      )
      if apply_w is not None:
          w = apply_w(w)
      b = None
      if with_bias:
          b = get_parameter_or_create(
              "b", (outmaps,), b_init, True, not fix_parameters
          )
          if apply_b is not None:
              b = apply_b(b)
      return F.convolution(
          inp,
          w,
          b,
          base_axis,
          pad,
          stride,
          dilation,
          group,
          channel_last,
      )
  
imports: from six import exec_
  import numpy
  import nnabla
  import nnabla.functions
  from nnabla.parameter import get_parameter_or_create, get_parameter
  from nnabla.initializer import calc_uniform_lim_glorot, ConstantInitializer, NormalInitializer, UniformInitializer, WeightNormalizationScaleInitializer
label_desc: Use image node_id 7 for calling a global function with example usage: convolution(inp, outmaps, kernel, pad, stride, dilation, group, channel_last, w_init, b_init, base_axis, fix_parameters, rng, with_bias, apply_w, apply_b) and returns: F