code: def check_X_y(
      X,
      y,
      accept_sparse=None,
      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,
      warn_on_dtype=False,
      estimator=None,
  ):
      """Input validation for standard estimators.
  
      Checks X and y for consistent length, enforces X 2d and y 1d.
      Standard input checks are only 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, list of string or None (default=None)
          String[s] representing allowed sparse matrix formats, such as 'csc',
          'csr', etc.  None means that sparse matrix input will raise an error.
          If the input is sparse but not in the allowed format, it will be
          converted to the first listed format.
  
      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 (default=True)
          Whether to raise an error on np.inf and np.nan in X. This parameter
          does not influence whether y can have np.inf or np.nan values.
  
      ensure_2d : boolean (default=True)
          Whether to make X at least 2d.
  
      allow_nd : boolean (default=False)
          Whether to allow X.ndim > 2.
  
      multi_output : boolean (default=False)
          Whether to allow 2-d 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.
  
      warn_on_dtype : boolean (default=False)
          Raise DataConversionWarning if the dtype of the input data structure
          does not match the requested dtype, causing a memory copy.
  
      estimator : str or estimator instance (default=None)
          If passed, include the name of the estimator in warning messages.
  
      Returns
      -------
      X_converted : object
          The converted and validated X.
  
      y_converted : object
          The converted and validated y.
      """
      X = check_array(
          X,
          accept_sparse,
          dtype,
          order,
          copy,
          force_all_finite,
          ensure_2d,
          allow_nd,
          ensure_min_samples,
          ensure_min_features,
          warn_on_dtype,
          estimator,
      )
      if multi_output:
          y = check_array(
              y,
              "csr",
              force_all_finite=True,
              ensure_2d=False,
              dtype=None,
          )
      else:
          y = column_or_1d(y, warn=True)
          _assert_all_finite(y)
      if y_numeric and y.dtype.kind == "O":
          y = y.astype(np.float64)
  
      check_consistent_length(X, y)
  
      return X, y
  
imports: import warnings
  import numbers
  import numpy
  import scipy.sparse
  from ..externals import six
  from ..utils.fixes import signature
  from .deprecation import deprecated
  from ..exceptions import DataConversionWarning
  from ..exceptions import NonBLASDotWarning
  from ..exceptions import NotFittedError
label_desc: Use image node_id 11 for calling a global function with example usage: check_X_y(X, y, accept_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, multi_output, ensure_min_samples, ensure_min_features, y_numeric, warn_on_dtype, estimator) and returns: X,  y