code: def csd(
      x,
      y,
      fs=1.0,
      window="hann",
      nperseg=None,
      noverlap=None,
      nfft=None,
      detrend="constant",
      return_onesided=True,
      scaling="density",
      axis=-1,
      average="mean",
  ):
      r"""
      Estimate the cross power spectral density, Pxy, using Welch's
      method.
  
      Parameters
      ----------
      x : array_like
          Time series of measurement values
      y : array_like
          Time series of measurement values
      fs : float, optional
          Sampling frequency of the `x` and `y` time series. Defaults
          to 1.0.
      window : str or tuple or array_like, optional
          Desired window to use. If `window` is a string or tuple, it is
          passed to `get_window` to generate the window values, which are
          DFT-even by default. See `get_window` for a list of windows and
          required parameters. If `window` is array_like it will be used
          directly as the window and its length must be nperseg. Defaults
          to a Hann window.
      nperseg : int, optional
          Length of each segment. Defaults to None, but if window is str or
          tuple, is set to 256, and if window is array_like, is set to the
          length of the window.
      noverlap: int, optional
          Number of points to overlap between segments. If `None`,
          ``noverlap = nperseg // 2``. Defaults to `None`.
      nfft : int, optional
          Length of the FFT used, if a zero padded FFT is desired. If
          `None`, the FFT length is `nperseg`. Defaults to `None`.
      detrend : str or function or `False`, optional
          Specifies how to detrend each segment. If `detrend` is a
          string, it is passed as the `type` argument to the `detrend`
          function. If it is a function, it takes a segment and returns a
          detrended segment. If `detrend` is `False`, no detrending is
          done. Defaults to 'constant'.
      return_onesided : bool, optional
          If `True`, return a one-sided spectrum for real data. If
          `False` return a two-sided spectrum. Defaults to `True`, but for
          complex data, a two-sided spectrum is always returned.
      scaling : { 'density', 'spectrum' }, optional
          Selects between computing the cross spectral density ('density')
          where `Pxy` has units of V**2/Hz and computing the cross spectrum
          ('spectrum') where `Pxy` has units of V**2, if `x` and `y` are
          measured in V and `fs` is measured in Hz. Defaults to 'density'
      axis : int, optional
          Axis along which the CSD is computed for both inputs; the
          default is over the last axis (i.e. ``axis=-1``).
      average : { 'mean', 'median' }, optional
          Method to use when averaging periodograms. Defaults to 'mean'.
  
  
      Returns
      -------
      f : ndarray
          Array of sample frequencies.
      Pxy : ndarray
          Cross spectral density or cross power spectrum of x,y.
  
      See Also
      --------
      periodogram: Simple, optionally modified periodogram
      lombscargle: Lomb-Scargle periodogram for unevenly sampled data
      welch: Power spectral density by Welch's method. [Equivalent to
             csd(x,x)]
      coherence: Magnitude squared coherence by Welch's method.
  
      Notes
      -----
      By convention, Pxy is computed with the conjugate FFT of X
      multiplied by the FFT of Y.
  
      If the input series differ in length, the shorter series will be
      zero-padded to match.
  
      An appropriate amount of overlap will depend on the choice of window
      and on your requirements. For the default Hann window an overlap of
      50% is a reasonable trade off between accurately estimating the
      signal power, while not over counting any of the data. Narrower
      windows may require a larger overlap.
  
      """
      x = cupy.asarray(x)
      y = cupy.asarray(y)
      freqs, _, Pxy = _spectral_helper(
          x,
          y,
          fs,
          window,
          nperseg,
          noverlap,
          nfft,
          detrend,
          return_onesided,
          scaling,
          axis,
          mode="psd",
      )
  
      # Average over windows.
      if len(Pxy.shape) >= 2 and Pxy.size > 0:
          if Pxy.shape[-1] > 1:
              if average == "median":
                  Pxy = cupy.median(Pxy, axis=-1) / _median_bias(
                      Pxy.shape[-1]
                  )
              elif average == "mean":
                  Pxy = Pxy.mean(axis=-1)
              else:
                  raise ValueError(
                      'average must be "median" or "mean", got %s'
                      % (average,)
                  )
          else:
              Pxy = cupy.reshape(Pxy, Pxy.shape[:-1])
  
      return freqs, Pxy
  
file_path: cupy/cupyx/scipy/signal/_spectral.py
imports: import warnings
  import cupy
  from cupyx.scipy.signal.windows._windows import get_window
  from cupyx.scipy.signal._spectral_impl import _lombscargle, _spectral_helper, _median_bias, _triage_segments
label_desc: Use image node_id 4 for calling a global function with example usage: csd(x, y, fs, window, nperseg, noverlap, nfft, detrend, return_onesided, scaling, axis, average) and returns: freqs,  Pxy