code: def correlate2d(
      in1,
      in2,
      mode="full",
      boundary="fill",
      fillvalue=0,
  ):
      """
      Cross-correlate two 2-dimensional arrays.
      Cross correlate `in1` and `in2` with output size determined by `mode`, and
      boundary conditions determined by `boundary` and `fillvalue`.
  
      Parameters
      ----------
      in1 : array_like
          First input.
      in2 : array_like
          Second input. Should have the same number of dimensions as `in1`.
      mode : str {'full', 'valid', 'same'}, optional
          A string indicating the size of the output:
          ``full``
             The output is the full discrete linear cross-correlation
             of the inputs. (Default)
          ``valid``
             The output consists only of those elements that do not
             rely on the zero-padding. In 'valid' mode, either `in1` or `in2`
             must be at least as large as the other in every dimension.
          ``same``
             The output is the same size as `in1`, centered
             with respect to the 'full' output.
      boundary : str {'fill', 'wrap', 'symm'}, optional
          A flag indicating how to handle boundaries:
          ``fill``
             pad input arrays with fillvalue. (default)
          ``wrap``
             circular boundary conditions.
          ``symm``
             symmetrical boundary conditions.
      fillvalue : scalar, optional
          Value to fill pad input arrays with. Default is 0.
  
      Returns
      -------
      correlate2d : ndarray
          A 2-dimensional array containing a subset of the discrete linear
          cross-correlation of `in1` with `in2`.
  
      Examples
      --------
      Use 2D cross-correlation to find the location of a template in a noisy
      image:
      >>> import cusignal
      >>> import cupy as cp
      >>> from scipy import misc
      >>> face = cp.asarray(misc.face(gray=True) - misc.face(gray=True).mean())
      >>> template = cp.copy(face[300:365, 670:750])  # right eye
      >>> template -= template.mean()
      >>> face = face + cp.random.randn(*face.shape) * 50  # add noise
      >>> corr = cusignal.correlate2d(face, template, boundary='symm', \
          mode='same')
      >>> y, x = cp.unravel_index(cp.argmax(corr), corr.shape)  # find the match
      >>> import matplotlib.pyplot as plt
      >>> fig, (ax_orig, ax_template, ax_corr) =
      ...     plt.subplots(3, 1, figsize=(6, 15))
      >>> ax_orig.imshow(cp.asnumpy(face), cmap='gray')
      >>> ax_orig.set_title('Original')
      >>> ax_orig.set_axis_off()
      >>> ax_template.imshow(cp.asnumpy(template), cmap='gray')
      >>> ax_template.set_title('Template')
      >>> ax_template.set_axis_off()
      >>> ax_corr.imshow(cp.asnumpy(corr), cmap='gray')
      >>> ax_corr.set_title('Cross-correlation')
      >>> ax_corr.set_axis_off()
      >>> ax_orig.plot(cp.asnumpy(x), cp.asnumpy(y), 'ro')
      >>> fig.show()
  
      """
  
      in1 = cp.asarray(in1)
      in2 = cp.asarray(in2)
  
      if not in1.ndim == in2.ndim == 2:
          raise ValueError("correlate2d inputs must both be 2D arrays")
  
      swapped_inputs = _inputs_swap_needed(mode, in1.shape, in2.shape)
      if swapped_inputs:
          in1, in2 = in2, in1
  
      out = _convolution_cuda._convolve2d(
          in1,
          in2.conj(),
          0,
          mode,
          boundary,
          fillvalue,
      )
  
      if swapped_inputs:
          out = out[::-1, ::-1]
  
      return out
  
imports: import cupy
  from .None import _convolution_cuda
  from .convolution_utils import _inputs_swap_needed, _reverse_and_conj
  from .convolve import convolve
label_desc: Use image node_id 2 for calling a global function with example usage: correlate2d(in1, in2, mode, boundary, fillvalue) and returns: out