code: def local_convolution_2d(x, W, b=None, stride=1):
      """Two-dimensional local convolution function.
  
      Locally-connected function for 2D inputs. Works similarly to
      convolution_2d, except that weights are unshared, that is, a different set
      of filters is applied at each different patch of the input.
      It takes two or three variables: the input image ``x``, the filter weight
      ``W``, and optionally, the bias vector ``b``.
  
      Notation: here is a notation for dimensionalities.
  
      - :math:`n` is the batch size.
      - :math:`c_I` is the number of the input.
      - :math:`c_O` is the number of output channels.
      - :math:`h` and :math:`w` are the height and width of the input image,
        respectively.
      - :math:`h_O` and :math:`w_O` are the height and width of the output image,
        respectively.
      - :math:`k_H` and :math:`k_W` are the height and width of the filters,
        respectively.
  
      Args:
          x (:class:`~chainer.Variable` or :ref:`ndarray`):
              Input variable of shape :math:`(n, c_I, h, w)`.
          W (:class:`~chainer.Variable` or :ref:`ndarray`): Weight variable of
              shape :math:`(c_O, h_O, w_O, c_I, k_H, k_W)`.
          b (:class:`~chainer.Variable` or :ref:`ndarray`):
              Bias variable of shape :math:`(c_O,h_O,w_O)` (optional).
          stride (int or pair of ints): Stride of filter applications.
              ``stride=s`` and ``stride=(s, s)`` are equivalent.
  
  
      Returns:
          ~chainer.Variable:
              Output variable. Its shape is :math:`(n, c_O, h_O, w_O)`.
  
      Like ``Convolution2D``, ``LocalConvolution2D`` function computes
      correlations between filters and patches of size :math:`(k_H, k_W)` in
      ``x``.
      But unlike ``Convolution2D``, ``LocalConvolution2D`` has a separate filter
      for each patch of the input
  
      :math:`(h_O, w_O)` is determined by the equivalent equation of
      ``Convolution2D``, without any padding
  
      If the bias vector is given, then it is added to all spatial locations of
      the output of convolution.
  
      .. seealso::
  
          :class:`~chainer.links.LocalConvolution2D` to manage the model
          parameters ``W`` and ``b``.
  
      .. admonition:: Example
  
          >>> x = np.random.uniform(0, 1, (2, 3, 7, 7))
          >>> W = np.random.uniform(0, 1, (2, 5, 5, 3, 3, 3))
          >>> b = np.random.uniform(0, 1, (2, 5, 5))
          >>> y = F.local_convolution_2d(x, W, b)
          >>> y.shape
          (2, 2, 5, 5)
  
      """
      fnode = LocalConvolution2DFunction(stride)
      if b is None:
          args = (x, W)
      else:
          args = (x, W, b)
      (y,) = fnode.apply(args)
      return y
  
file_path: chainer/chainer/functions/connection/local_convolution_2d.py
imports: from six import moves
  import chainer
  from chainer import backend
  from chainer import function_node
  from chainer.utils import type_check
  from chainer import variable
label_desc: Use image node_id 2 for calling a global function with example usage: local_convolution_2d(x, W, b, stride) and returns: y