code: def check_X_y(
      X,
      y,
      accept_sparse=False,
      *,
      accept_large_sparse=True,
      dtype="numeric",
      order=None,
      copy=False,
      force_all_finite=True,
      ensure_2d=True,
      allow_nd=False,
      multi_output=False,
      ensure_min_samples=1,
      ensure_min_features=1,
      y_numeric=False,
  ):
      """Input validation for standard estimators.
  
      Checks X and y for consistent length, enforces X to be 2D and y 1D. By
      default, X is checked to be non-empty and containing only finite values.
      Standard input checks are also applied to y, such as checking that y
      does not have np.nan or np.inf targets. For multi-label y, set
      multi_output=True to allow 2D and sparse y. If the dtype of X is
      object, attempt converting to float, raising on failure.
  
      Parameters
      ----------
      X : nd-array, list or sparse matrix
          Input data.
  
      y : nd-array, list or sparse matrix
          Labels.
  
      accept_sparse : string, boolean or list of string (default=False)
          String[s] representing allowed sparse matrix formats, such as 'csc',
          'csr', etc. If the input is sparse but not in the allowed format,
          it will be converted to the first listed format. True allows the input
          to be any format. False means that a sparse matrix input will
          raise an error.
  
      accept_large_sparse : bool (default=True)
          If a CSR, CSC, COO or BSR sparse matrix is supplied and accepted by
          accept_sparse, accept_large_sparse will cause it to be accepted only
          if its indices are stored with a 32-bit dtype.
  
      dtype : string, type, list of types or None (default="numeric")
          Data type of result. If None, the dtype of the input is preserved.
          If "numeric", dtype is preserved unless array.dtype is object.
          If dtype is a list of types, conversion on the first type is only
          performed if the dtype of the input is not in the list.
  
      order : 'F', 'C' or None (default=None)
          Whether an array will be forced to be fortran or c-style.
  
      copy : boolean (default=False)
          Whether a forced copy will be triggered. If copy=False, a copy might
          be triggered by a conversion.
  
      force_all_finite : boolean or 'allow-nan', (default=True)
          Whether to raise an error on np.inf, np.nan, pd.NA in X. This parameter
          does not influence whether y can have np.inf, np.nan, pd.NA values.
          The possibilities are:
  
          - True: Force all values of X to be finite.
          - False: accepts np.inf, np.nan, pd.NA in X.
          - 'allow-nan': accepts only np.nan or pd.NA values in X. Values cannot
            be infinite.
  
      ensure_2d : boolean (default=True)
          Whether to raise a value error if X is not 2D.
  
      allow_nd : boolean (default=False)
          Whether to allow X.ndim > 2.
  
      multi_output : boolean (default=False)
          Whether to allow 2D y (array or sparse matrix). If false, y will be
          validated as a vector. y cannot have np.nan or np.inf values if
          multi_output=True.
  
      ensure_min_samples : int (default=1)
          Make sure that X has a minimum number of samples in its first
          axis (rows for a 2D array).
  
      ensure_min_features : int (default=1)
          Make sure that the 2D array has some minimum number of features
          (columns). The default value of 1 rejects empty datasets.
          This check is only enforced when X has effectively 2 dimensions or
          is originally 1D and ``ensure_2d`` is True. Setting to 0 disables
          this check.
  
      y_numeric : boolean (default=False)
          Whether to ensure that y has a numeric type. If dtype of y is object,
          it is converted to float64. Should only be used for regression
          algorithms.
  
      Returns
      -------
      X_converted : object
          The converted and validated X.
  
      y_converted : object
          The converted and validated y.
      """
      if y is None:
          raise ValueError("y cannot be None")
  
      X = check_array(
          X,
          accept_sparse=accept_sparse,
          accept_large_sparse=accept_large_sparse,
          dtype=dtype,
          order=order,
          copy=copy,
          force_all_finite=force_all_finite,
          ensure_2d=ensure_2d,
          allow_nd=allow_nd,
          ensure_min_samples=ensure_min_samples,
          ensure_min_features=ensure_min_features,
      )
  
      y = check_array(
          y,
          accept_sparse="csr",
          force_all_finite=True,
          ensure_2d=False,
          dtype="numeric" if y_numeric else None,
      )
  
      if not multi_output and y.ndim > 1:
          if y.shape[1] > 1:
              raise ValueError(
                  "y should be a 1d array, "
                  "got an array of shape {} instead.".format(y.shape)
              )
  
      if X.shape[0] != y.shape[0]:
          raise ValueError(
              "Found input variables with inconsistent numbers of"
              " samples"
          )
  
      return X, y
  
file_path: cuml/python/cuml/_thirdparty/sklearn/utils/validation.py
imports: from ....thirdparty_adapters import check_array
  from ....common.exceptions import NotFittedError
  from inspect import isclass
  from cuml.internals.safe_imports import gpu_only_import
  import numbers
  from cuml.internals.safe_imports import cpu_only_import
label_desc: Use image node_id 1 for calling a global function with example usage: check_X_y(X, y, accept_sparse) and returns: X,  y