original_docstring: Input validation on an array, list, sparse matrix or similar.
      By default, the input is checked to be a non-empty 2D array containing
      only finite values. If the dtype of the array is object, attempt
      converting to float, raising on failure.
      Parameters
      ----------
      array : object
          Input object to check / convert.
      accept_sparse : string, boolean or list/tuple of strings (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=False will cause it to be accepted
          only if its indices are stored with a 32-bit dtype.
          .. versionadded:: 0.20
      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.
          When order is None (default), then if copy=False, nothing is ensured
          about the memory layout of the output array; otherwise (copy=True)
          the memory layout of the returned array is kept as close as possible
          to the original array.
      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 and np.nan in array. The
          possibilities are:
          - True: Force all values of array to be finite.
          - False: accept both np.inf and np.nan in array.
          - 'allow-nan': accept only np.nan values in array. Values cannot
            be infinite.
          For object dtyped data, only np.nan is checked and not np.inf.
          .. versionadded:: 0.20
             ``force_all_finite`` accepts the string ``'allow-nan'``.
      ensure_2d : boolean (default=True)
          Whether to raise a value error if array is not 2D.
      allow_nd : boolean (default=False)
          Whether to allow array.ndim > 2.
      ensure_min_samples : int (default=1)
          Make sure that the array has a minimum number of samples in its first
          axis (rows for a 2D array). Setting to 0 disables this check.
      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 the input data has effectively 2
          dimensions or is originally 1D and ``ensure_2d`` is True. Setting to 0
          disables this check.
      estimator : str or estimator instance (default=None)
          If passed, include the name of the estimator in warning messages.
      Returns
      -------
      array_converted : object
          The converted and validated array.
      
docstring: Input validation on an array, list, sparse matrix or similar.
  By default, the input is checked to be a non-empty 2D array containing
  only finite values. If the dtype of the array is object, attempt
  converting to float, raising on failure.
  Parameters
  
  array : object
  Input object to check / convert.
  accept_sparse : string, boolean or list/tuple of strings (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=False will cause it to be accepted
  only if its indices are stored with a 32-bit dtype.
  versionadded:: 0.20
  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.
  When order is None (default), then if copy=False, nothing is ensured
  about the memory layout of the output array; otherwise (copy=True)
  the memory layout of the returned array is kept as close as possible
  to the original array.
  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 and np.nan in array. The
  possibilities are:
  True: Force all values of array to be finite.
  
  array_converted : object
  The converted and validated array.
docstring_tokens: Input validation on an array list sparse matrix or similar . By default the input is checked to be a non - empty 2D array containing only finite values . If the dtype of the array is object attempt converting to float raising on failure . Parameters array : object Input object to check / convert . accept_sparse : string boolean or list / tuple of strings ( 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 = False will cause it to be accepted only if its indices are stored with a 32 - bit dtype . versionadded :: 0 . 20 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 . When order is None ( default ) then if copy = False nothing is ensured about the memory layout of the output array ; otherwise ( copy = True ) the memory layout of the returned array is kept as close as possible to the original array . 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 and np . nan in array . The possibilities are : True : Force all values of array to be finite . array_converted : object The converted and validated array .
code: def check_array(array, accept_sparse=False, accept_large_sparse=True,
                  dtype="numeric", order=None, copy=False, force_all_finite=True,
                  ensure_2d=True, allow_nd=False, ensure_min_samples=1,
                  ensure_min_features=1, estimator=None):
  
      """Input validation on an array, list, sparse matrix or similar.
      By default, the input is checked to be a non-empty 2D array containing
      only finite values. If the dtype of the array is object, attempt
      converting to float, raising on failure.
      Parameters
      ----------
      array : object
          Input object to check / convert.
      accept_sparse : string, boolean or list/tuple of strings (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=False will cause it to be accepted
          only if its indices are stored with a 32-bit dtype.
          .. versionadded:: 0.20
      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.
          When order is None (default), then if copy=False, nothing is ensured
          about the memory layout of the output array; otherwise (copy=True)
          the memory layout of the returned array is kept as close as possible
          to the original array.
      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 and np.nan in array. The
          possibilities are:
          - True: Force all values of array to be finite.
          - False: accept both np.inf and np.nan in array.
          - 'allow-nan': accept only np.nan values in array. Values cannot
            be infinite.
          For object dtyped data, only np.nan is checked and not np.inf.
          .. versionadded:: 0.20
             ``force_all_finite`` accepts the string ``'allow-nan'``.
      ensure_2d : boolean (default=True)
          Whether to raise a value error if array is not 2D.
      allow_nd : boolean (default=False)
          Whether to allow array.ndim > 2.
      ensure_min_samples : int (default=1)
          Make sure that the array has a minimum number of samples in its first
          axis (rows for a 2D array). Setting to 0 disables this check.
      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 the input data has effectively 2
          dimensions or is originally 1D and ``ensure_2d`` is True. Setting to 0
          disables this check.
      estimator : str or estimator instance (default=None)
          If passed, include the name of the estimator in warning messages.
      Returns
      -------
      array_converted : object
          The converted and validated array.
      """
      # store reference to original array to check if copy is needed when
      # function returns
      array_orig = array
  
      # store whether originally we wanted numeric dtype
      dtype_numeric = isinstance(dtype, str) and dtype == "numeric"
  
      dtype_orig = getattr(array, "dtype", None)
      if not hasattr(dtype_orig, 'kind'):
          # not a data type (e.g. a column named dtype in a pandas DataFrame)
          dtype_orig = None
  
      # check if the object contains several dtypes (typically a pandas
      # DataFrame), and store them. If not, store None.
      dtypes_orig = None
      if hasattr(array, "dtypes") and hasattr(array.dtypes, '__array__'):
          # throw warning if pandas dataframe is sparse
  
          dtypes_orig = list(array.dtypes)
          # pandas boolean dtype __array__ interface coerces bools to objects
          for i, dtype_iter in enumerate(dtypes_orig):
              if dtype_iter.kind == 'b':
                  dtypes_orig[i] = np.object
  
          if all(isinstance(dtype, np.dtype) for dtype in dtypes_orig):
              dtype_orig = np.result_type(*dtypes_orig)
  
      if dtype_numeric:
          if dtype_orig is not None and dtype_orig.kind == "O":
              # if input is object, convert to float.
              dtype = np.float64
          else:
              dtype = None
  
      if isinstance(dtype, (list, tuple)):
          if dtype_orig is not None and dtype_orig in dtype:
              # no dtype conversion required
              dtype = None
          else:
              # dtype conversion required. Let's select the first element of the
              # list of accepted types.
              dtype = dtype[0]
  
      if force_all_finite not in (True, False, 'allow-nan'):
          raise ValueError('force_all_finite should be a bool or "allow-nan"'
                           '. Got {!r} instead'.format(force_all_finite))
  
      if estimator is not None:
          if isinstance(estimator, str):
              estimator_name = estimator
          else:
              estimator_name = estimator.__class__.__name__
      else:
          estimator_name = "Estimator"
      context = " by %s" % estimator_name if estimator is not None else ""
  
      if sp.issparse(array):
          _ensure_no_complex_data(array)
          array = _ensure_sparse_format(array, accept_sparse=accept_sparse,
                                        dtype=dtype, copy=copy,
                                        force_all_finite=force_all_finite,
                                        accept_large_sparse=accept_large_sparse)
      else:
          # If np.array(..) gives ComplexWarning, then we convert the warning
          # to an error. This is needed because specifying a non complex
          # dtype to the function converts complex to real dtype,
          # thereby passing the test made in the lines following the scope
          # of warnings context manager.
          with warnings.catch_warnings():
              try:
                  warnings.simplefilter('error', ComplexWarning)
                  if dtype is not None and np.dtype(dtype).kind in 'iu':
                      # Conversion float -> int should not contain NaN or
                      # inf (numpy#14412). We cannot use casting='safe' because
                      # then conversion float -> int would be disallowed.
                      array = np.asarray(array, order=order)
                      if array.dtype.kind == 'f':
                          _assert_all_finite(array, allow_nan=False,
                                             msg_dtype=dtype)
                      array = array.astype(dtype, casting="unsafe", copy=False)
                  else:
                      array = np.asarray(array, order=order, dtype=dtype)
              except ComplexWarning:
                  raise ValueError("Complex data not supported\n"
                                   "{}\n".format(array))
  
          # It is possible that the np.array(..) gave no warning. This happens
          # when no dtype conversion happened, for example dtype = None. The
          # result is that np.array(..) produces an array of complex dtype
          # and we need to catch and raise exception for such cases.
          _ensure_no_complex_data(array)
  
          if ensure_2d:
              # If input is scalar raise error
              if array.ndim == 0:
                  raise ValueError(
                      "Expected 2D array, got scalar array instead:\narray={}.\n"
                      "Reshape your data either using array.reshape(-1, 1) if "
                      "your data has a single feature or array.reshape(1, -1) "
                      "if it contains a single sample.".format(array))
              # If input is 1D raise error
              if array.ndim == 1:
                  raise ValueError(
                      "Expected 2D array, got 1D array instead:\narray={}.\n"
                      "Reshape your data either using array.reshape(-1, 1) if "
                      "your data has a single feature or array.reshape(1, -1) "
                      "if it contains a single sample.".format(array))
  
          # in the future np.flexible dtypes will be handled like object dtypes
          if dtype_numeric and np.issubdtype(array.dtype, np.flexible):
              warnings.warn(
                  "Beginning in version 0.22, arrays of bytes/strings will be "
                  "converted to decimal numbers if dtype='numeric'. "
                  "It is recommended that you convert the array to "
                  "a float dtype before using it in scikit-learn, "
                  "for example by using "
                  "your_array = your_array.astype(np.float64).",
                  FutureWarning, stacklevel=2)
  
          # make sure we actually converted to numeric:
          if dtype_numeric and array.dtype.kind == "O":
              array = array.astype(np.float64)
          if not allow_nd and array.ndim >= 3:
              raise ValueError("Found array with dim %d. %s expected <= 2."
                               % (array.ndim, estimator_name))
  
          if force_all_finite:
              _assert_all_finite(array,
                                 allow_nan=force_all_finite == 'allow-nan')
  
      if ensure_min_samples > 0:
          n_samples = _num_samples(array)
          if n_samples < ensure_min_samples:
              raise ValueError("Found array with %d sample(s) (shape=%s) while a"
                               " minimum of %d is required%s."
                               % (n_samples, array.shape, ensure_min_samples,
                                  context))
  
      if ensure_min_features > 0 and array.ndim == 2:
          n_features = array.shape[1]
          if n_features < ensure_min_features:
              raise ValueError("Found array with %d feature(s) (shape=%s) while"
                               " a minimum of %d is required%s."
                               % (n_features, array.shape, ensure_min_features,
                                  context))
  
      if copy and np.may_share_memory(array, array_orig):
          array = np.array(array, dtype=dtype, order=order)
  
      return array
code_tokens: def check_array ( array , accept_sparse = False , accept_large_sparse = True , dtype = "numeric" , order = None , copy = False , force_all_finite = True , ensure_2d = True , allow_nd = False , ensure_min_samples = 1 , ensure_min_features = 1 , estimator = None ) : array_orig = array dtype_numeric = isinstance ( dtype , str ) and dtype == "numeric" dtype_orig = getattr ( array , "dtype" , None ) if not hasattr ( dtype_orig , 'kind' ) : dtype_orig = None dtypes_orig = None if hasattr ( array , "dtypes" ) and hasattr ( array . dtypes , '__array__' ) : dtypes_orig = list ( array . dtypes ) for i , dtype_iter in enumerate ( dtypes_orig ) : if dtype_iter . kind == 'b' : dtypes_orig [ i ] = np . object if all ( isinstance ( dtype , np . dtype ) for dtype in dtypes_orig ) : dtype_orig = np . result_type ( * dtypes_orig ) if dtype_numeric : if dtype_orig is not None and dtype_orig . kind == "O" : dtype = np . float64 else : dtype = None if isinstance ( dtype , ( list , tuple ) ) : if dtype_orig is not None and dtype_orig in dtype : dtype = None else : dtype = dtype [ 0 ] if force_all_finite not in ( True , False , 'allow-nan' ) : raise ValueError ( 'force_all_finite should be a bool or "allow-nan"' '. Got {!r} instead' . format ( force_all_finite ) ) if estimator is not None : if isinstance ( estimator , str ) : estimator_name = estimator else : estimator_name = estimator . __class__ . __name__ else : estimator_name = "Estimator" context = " by %s" % estimator_name if estimator is not None else "" if sp . issparse ( array ) : _ensure_no_complex_data ( array ) array = _ensure_sparse_format ( array , accept_sparse = accept_sparse , dtype = dtype , copy = copy , force_all_finite = force_all_finite , accept_large_sparse = accept_large_sparse ) else : with warnings . catch_warnings ( ) : try : warnings . simplefilter ( 'error' , ComplexWarning ) if dtype is not None and np . dtype ( dtype ) . kind in 'iu' : array = np . asarray ( array , order = order ) if array . dtype . kind == 'f' : _assert_all_finite ( array , allow_nan = False , msg_dtype = dtype ) array = array . astype ( dtype , casting = "unsafe" , copy = False ) else : array = np . asarray ( array , order = order , dtype = dtype ) except ComplexWarning : raise ValueError ( "Complex data not supported\n" "{}\n" . format ( array ) ) _ensure_no_complex_data ( array ) if ensure_2d : if array . ndim == 0 : raise ValueError ( "Expected 2D array, got scalar array instead:\narray={}.\n" "Reshape your data either using array.reshape(-1, 1) if " "your data has a single feature or array.reshape(1, -1) " "if it contains a single sample." . format ( array ) ) if array . ndim == 1 : raise ValueError ( "Expected 2D array, got 1D array instead:\narray={}.\n" "Reshape your data either using array.reshape(-1, 1) if " "your data has a single feature or array.reshape(1, -1) " "if it contains a single sample." . format ( array ) ) if dtype_numeric and np . issubdtype ( array . dtype , np . flexible ) : warnings . warn ( "Beginning in version 0.22, arrays of bytes/strings will be " "converted to decimal numbers if dtype='numeric'. " "It is recommended that you convert the array to " "a float dtype before using it in scikit-learn, " "for example by using " "your_array = your_array.astype(np.float64)." , FutureWarning , stacklevel = 2 ) if dtype_numeric and array . dtype . kind == "O" : array = array . astype ( np . float64 ) if not allow_nd and array . ndim >= 3 : raise ValueError ( "Found array with dim %d. %s expected <= 2." % ( array . ndim , estimator_name ) ) if force_all_finite : _assert_all_finite ( array , allow_nan = force_all_finite == 'allow-nan' ) if ensure_min_samples > 0 : n_samples = _num_samples ( array ) if n_samples < ensure_min_samples : raise ValueError ( "Found array with %d sample(s) (shape=%s) while a" " minimum of %d is required%s." % ( n_samples , array . shape , ensure_min_samples , context ) ) if ensure_min_features > 0 and array . ndim == 2 : n_features = array . shape [ 1 ] if n_features < ensure_min_features : raise ValueError ( "Found array with %d feature(s) (shape=%s) while" " a minimum of %d is required%s." % ( n_features , array . shape , ensure_min_features , context ) ) if copy and np . may_share_memory ( array , array_orig ) : array = np . array ( array , dtype = dtype , order = order ) return array
short_docstring: Input validation on an array, list, sparse matrix or similar.
short_docstring_tokens: Input validation on an array list sparse matrix or similar .
comment: """Input validation on an array, list, sparse matrix or similar.
      By default, the input is checked to be a non-empty 2D array containing
      only finite values. If the dtype of the array is object, attempt
      converting to float, raising on failure.
      Parameters
      ----------
      array : object
          Input object to check / convert.
      accept_sparse : string, boolean or list/tuple of strings (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=False will cause it to be accepted
          only if its indices are stored with a 32-bit dtype.
          .. versionadded:: 0.20
      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.
          When order is None (default), then if copy=False, nothing is ensured
          about the memory layout of the output array; otherwise (copy=True)
          the memory layout of the returned array is kept as close as possible
          to the original array.
      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 and np.nan in array. The
          possibilities are:
          - True: Force all values of array to be finite.
          - False: accept both np.inf and np.nan in array.
          - 'allow-nan': accept only np.nan values in array. Values cannot
            be infinite.
          For object dtyped data, only np.nan is checked and not np.inf.
          .. versionadded:: 0.20
             ``force_all_finite`` accepts the string ``'allow-nan'``.
      ensure_2d : boolean (default=True)
          Whether to raise a value error if array is not 2D.
      allow_nd : boolean (default=False)
          Whether to allow array.ndim > 2.
      ensure_min_samples : int (default=1)
          Make sure that the array has a minimum number of samples in its first
          axis (rows for a 2D array). Setting to 0 disables this check.
      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 the input data has effectively 2
          dimensions or is originally 1D and ``ensure_2d`` is True. Setting to 0
          disables this check.
      estimator : str or estimator instance (default=None)
          If passed, include the name of the estimator in warning messages.
      Returns
      -------
      array_converted : object
          The converted and validated array.
      """$SEP$# store reference to original array to check if copy is needed when$SEP$# function returns$SEP$# store whether originally we wanted numeric dtype$SEP$# not a data type (e.g. a column named dtype in a pandas DataFrame)$SEP$# check if the object contains several dtypes (typically a pandas$SEP$# DataFrame), and store them. If not, store None.$SEP$# throw warning if pandas dataframe is sparse$SEP$# pandas boolean dtype __array__ interface coerces bools to objects$SEP$# if input is object, convert to float.$SEP$# no dtype conversion required$SEP$# dtype conversion required. Let's select the first element of the$SEP$# list of accepted types.$SEP$# If np.array(..) gives ComplexWarning, then we convert the warning$SEP$# to an error. This is needed because specifying a non complex$SEP$# dtype to the function converts complex to real dtype,$SEP$# thereby passing the test made in the lines following the scope$SEP$# of warnings context manager.$SEP$# Conversion float -> int should not contain NaN or$SEP$# inf (numpy#14412). We cannot use casting='safe' because$SEP$# then conversion float -> int would be disallowed.$SEP$# It is possible that the np.array(..) gave no warning. This happens$SEP$# when no dtype conversion happened, for example dtype = None. The$SEP$# result is that np.array(..) produces an array of complex dtype$SEP$# and we need to catch and raise exception for such cases.$SEP$# If input is scalar raise error$SEP$# If input is 1D raise error$SEP$# in the future np.flexible dtypes will be handled like object dtypes$SEP$# make sure we actually converted to numeric: