code: def channelize_poly(x, h, n_chans):
      """
      Polyphase channelize signal into n channels
  
      Parameters
      ----------
      x : array_like
          The input data to be channelized
      h : array_like
          The 1-D input filter; will be split into n
          channels of int number of taps
      n_chans : int
          Number of channels for channelizer
  
      Returns
      -------
      yy : channelized output matrix
  
      Notes
      -----
      Currently only supports simple channelizer where channel
      spacing is equivalent to the number of channels used (zero overlap).
      Number of filter taps (len of filter / n_chans) must be <=32.
  
      """
      dtype = cp.promote_types(x.dtype, h.dtype)
  
      x = cp.asarray(x, dtype=dtype)
      h = cp.asarray(h, dtype=dtype)
  
      # number of taps in each h_n filter
      n_taps = int(len(h) / n_chans)
      if n_taps > 32:
          raise NotImplementedError(
              "The number of calculated taps ({}) in  \
              each filter is currently capped at 32. Please reduce filter \
                  length or number of channels".format(
                  n_taps
              )
          )
  
      # number of outputs
      n_pts = int(len(x) / n_chans)
  
      if x.dtype == np.float32 or x.dtype == np.complex64:
          y = cp.empty((n_pts, n_chans), dtype=cp.complex64)
      elif x.dtype == np.float64 or x.dtype == np.complex128:
          y = cp.empty((n_pts, n_chans), dtype=cp.complex128)
      else:
          raise NotImplementedError(
              "Data type ({}) not allowed.".format(x.dtype)
          )
  
      _channelizer(x, h, y, n_chans, n_taps, n_pts)
  
      return cp.conj(cp.fft.fft(y)).T
  
imports: import cupy
  import numpy
  from cupyx.scipy import linalg
  from ..convolution.correlate import correlate
  from ..filter_design.filter_design_utils import _validate_sos
  from ..utils.arraytools import _axis_reverse, _axis_slice, _const_ext, _even_ext, _odd_ext
  from ..utils.helper_tools import _get_max_smem, _get_max_tpb
  from ._channelizer_cuda import _channelizer
  from ._sosfilt_cuda import _sosfilt
label_desc: Use image node_id 14 for calling a global function with example usage: channelize_poly(x, h, n_chans) and returns: cp