B vd@s6dZddlmZddlZddlZddlZddlZddlm Z ddl m Z m Z mZddlmZddlZddlmZddlmZmZd d lmZd d lmZd d lmZd d lmZejejej fZ!d[ddddZ"d\ddZ#ddddZ$dddddZ%ddZ&ddZ'd d!Z(d"d#Z)d$d%Z*d&d'Z+d(d)Z,d*d+Z-d,d-Z.d]dd.ddddddddd/ d0d1Z/d^d2d3Z0d_dd.ddddddddddd4 d5d6Z1d`d7d8Z2dd9d:d;Z3dd?Z5d@dddAdBdCZ6dade7dDdEdFZ8dGdHZ9dddIdJdKdLZ:dbdMdNZ;dcdOdPZdWdXZ?dfdYdZZ@dS)gzUtilities for input validation)wrapsN) signatureisclass Parameter)ComplexWarning)suppress)_object_dtype_isnan parse_version) get_config)PositiveSpectrumWarning)NotFittedError)DataConversionWarningz1.1 (renaming of 0.26))versioncs fdd}|dk r||S|S)aDecorator for methods that issues warnings for positional arguments. Using the keyword-only argument syntax in pep 3102, arguments after the * will issue a warning when passed as a positional argument. Parameters ---------- func : callable, default=None Function to check arguments on. version : callable, default="1.1 (renaming of 0.26)" The version when positional arguments will result in error. csvtggxDjD]6\}}|jtjkr<|q|jtjkr|qWtfdd}|S)Ncst|t}|dkr"||Sddtd||| dD}d|}td|ddt|tj|f|S)NrcSsg|]\}}d||qS)z{}={})format).0nameargre/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sklearn/utils/validation.py Eszi_deprecate_positional_args.._inner_deprecate_positional_args..inner_f..z, zPass z as keyword args. From version z> passing these as positional arguments will result in an error)lenzipjoinwarningswarn FutureWarningupdate parameters)argskwargs extra_argsZargs_msg)all_argsf kwonly_argssigrrrinner_f=s   zU_deprecate_positional_args.._inner_deprecate_positional_args..inner_f) rritemskindrPOSITIONAL_OR_KEYWORDappend KEYWORD_ONLYr)r$rparamr')r)r#r$r%r&r _inner_deprecate_positional_args2s   zD_deprecate_positional_args.._inner_deprecate_positional_argsNr)funcrr.r)rr_deprecate_positional_args$s "r0FcCsddlm}tdrdSt|}|jjdk}|rHt|tj|rHn|rd}|rbt | st|st| s|r|dnd}t | ||dk r|n|jn(|jtd kr|st| rt d dS) z-Like assert_all_finite, but only for ndarray.r)_safe_accumulator_opZ assume_finiteNfcz0Input contains {} or a value too large for {!r}.infinityz NaN, infinityobjectzInput contains NaN)Zextmathr1 _get_confignpZ asanyarraydtyper)isfinitesumisinfanyall ValueErrorrr )X allow_nan msg_dtyper1Zis_floatZmsg_errZtype_errrrr_assert_all_finiteZs(      rA)r?cCstt|r|jn||dS)zThrow a ValueError if X contains NaN or infinity. Parameters ---------- X : {ndarray, sparse matrix} allow_nan : bool, default=False N)rAspissparsedata)r>r?rrrassert_all_finite}s rET)copyforce_all_finitecCst|tjs"t|tjs>t|s>t|dddgtj||ddSt|rj|jtj tjgkrj|rf| S|S|jtj tjgkr|r| |j drdndS|S|jj d kr|jj d krtj }ntj}||Sd S) akConvert an array-like to an array of floats. The new dtype will be np.float32 or np.float64, depending on the original type. The function can create a copy or modify the argument depending on the argument copy. Parameters ---------- X : {array-like, sparse matrix} The input data. copy : bool, default=True If True, a copy of X will be created. If False, a copy may still be returned if X's dtype is not a floating point type. force_all_finite : bool or 'allow-nan', default=True Whether to raise an error on np.inf, np.nan, pd.NA in X. 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 and pd.NA values in X. Values cannot be infinite. .. versionadded:: 0.20 ``force_all_finite`` accepts the string ``'allow-nan'``. .. versionchanged:: 0.23 Accepts `pd.NA` and converts it into `np.nan` Returns ------- XT : {ndarray, sparse matrix} An array of type float. csrcsccooF) accept_sparser7rFrG ensure_2dZ F_CONTIGUOUSFCZuibN) isinstancer6matrixZndarrayrBrC check_arrayfloat64r7float32rFflagsr)itemsizeastype)r>rFrGZ return_dtyperrras_float_arrays"$  rXcCst|dpt|dpt|dS)z(Returns whether the input is array-like.__len__shape __array__)hasattr)xrrr _is_arraylikesr^c Cst|}|jdkr|j}n|jd|j}d|}t|dsft|dsft|ds\t|t|}t|drt|jdrt|jdkr|d|j7}t||jdS|d }t |t t t fr|d t|j7}t|yt|St k r}zt||Wd d }~XYnXd S) a Return the number of features in an array-like X. This helper function tries hard to avoid to materialize an array version of X unless necessary. For instance, if X is a list of lists, this function will return the length of the first element, assuming that subsequent elements are all lists of the same length without checking. Parameters ---------- X : array-like array-like to get the number of features. Returns ------- features : int Number of features builtins.z5Unable to find the number of features from X of type rYrZr[rz with shape rz where the samples are of type N)type __module__ __qualname__r\ TypeErrorr6asarrayrZrrPstrbytesdict Exception)r>type_ type_namemessageZ first_sampleerrrrr _num_featuress,      rnc Csdt|}t|dr(t|jr(t|t|dsZt|dsZt|drRt|}nt|t|dr|jdk rt|jdkrtd|t |jdt j r|jdSyt|Stk r}zt||Wdd}~XYnXdS) z)Return number of samples in array-like x.z'Expected sequence or array-like, got %sfitrYrZr[Nrz;Singleton array %r cannot be considered a valid collection.) rar\callablerordr6rerZrrPnumbersIntegral)r]rlZ type_errorrrr _num_sampless"     rscCs`|dkst|trDttjtdkr4tj|dd}q\tj|dd}nt|ds\td||S)aCheck that ``memory`` is joblib.Memory-like. joblib.Memory-like means that ``memory`` can be converted into a joblib.Memory instance (typically a str denoting the ``location``) or has the same interface (has a ``cache`` method). Parameters ---------- memory : None, str or object with the joblib.Memory interface Returns ------- memory : object with the joblib.Memory interface Raises ------ ValueError If ``memory`` is not joblib.Memory-like. Nz0.12r)Zcachedirverbose)locationrtcachezg'memory' should be None, a string or have the same interface as joblib.Memory. Got memory='{}' instead.) rPrfr joblib __version__ZMemoryr\r=r)Zmemoryrrr check_memorys rycGs>dd|D}t|}t|dkr:tddd|DdS)aCheck that all arrays have consistent first dimensions. Checks whether all objects in arrays have the same shape or length. Parameters ---------- *arrays : list or tuple of input objects. Objects that will be checked for consistent length. cSsg|]}|dk rt|qS)N)rs)rr>rrrrIsz+check_consistent_length..rz>Found input variables with inconsistent numbers of samples: %rcSsg|] }t|qSr)int)rlrrrrNsN)r6uniquerr=)ZarrayslengthsZuniquesrrrcheck_consistent_length>s   r~cCs@t|r|St|ds&t|dr*|S|dkr6|St|S)aEnsure iterable supports indexing or convert to an indexable variant. Convert sparse matrices to csr and other non-indexable iterable to arrays. Let `None` and indexable objects (e.g. pandas dataframes) pass unchanged. Parameters ---------- iterable : {list, dataframe, ndarray, sparse matrix} or None Object to be converted to an indexable iterable. __getitem__ZilocN)rBrCtocsrr\r6array)iterablerrr_make_indexableRs rcGsdd|D}t||S)aKMake arrays indexable for cross-validation. Checks consistent length, passes through None, and ensures that everything can be indexed by converting sparse matrices to csr and converting non-interable objects to arrays. Parameters ---------- *iterables : {lists, dataframes, ndarrays, sparse matrices} List of objects to ensure sliceability. Returns ------- result : list of {ndarray, sparse matrix, dataframe} or None Returns a list containing indexable arrays (i.e. NumPy array, sparse matrix, or dataframe) or `None`. cSsg|] }t|qSr)r)rr>rrrryszindexable..)r~) iterablesresultrrr indexablefsrcCs|dkr|j}d}t|tr"|g}t|||dkr>tdnVt|ttfr~t|dkr`td|j |kr| |d}d}n|dk rtd |||jkr| |}n|r|s| }|rt |dstjd |j d d nt|j|d kd |S)aConvert a sparse matrix to a given format. Checks the sparse format of spmatrix and converts if necessary. Parameters ---------- spmatrix : sparse matrix Input to validate and convert. accept_sparse : str, bool or list/tuple of str String[s] representing allowed sparse matrix formats ('csc', 'csr', 'coo', 'dok', 'bsr', 'lil', 'dia'). 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. dtype : str, type or None Data type of result. If None, the dtype of the input is preserved. copy : bool Whether a forced copy will be triggered. If copy=False, a copy might be triggered by a conversion. force_all_finite : bool or 'allow-nan' Whether to raise an error on np.inf, np.nan, pd.NA in X. 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 and pd.NA values in X. Values cannot be infinite. .. versionadded:: 0.20 ``force_all_finite`` accepts the string ``'allow-nan'``. .. versionchanged:: 0.23 Accepts `pd.NA` and converts it into `np.nan` Returns ------- spmatrix_converted : sparse matrix. Matrix that is ensured to have an allowed type. NFzjA sparse matrix was passed, but dense data is required. Use X.toarray() to convert to a dense numpy array.rz]When providing 'accept_sparse' as a tuple or list, it must contain at least one string value.TzjParameter 'accept_sparse' should be a string, boolean or list of strings. You provided 'accept_sparse={}'.rDz,Can't check %s sparse matrix for nan or inf.r ) stacklevelz allow-nan)r?)r7rPrf_check_large_sparserdlisttuplerr=rZasformatrWrFr\rrrArD)ZspmatrixrKr7rFrGaccept_large_sparseZchanged_formatrrr_ensure_sparse_format~s>.        rcCs>t|dr:|jdk r:t|jdr:|jjdkr:td|dS)Nr7r)czComplex data not supported {} )r\r7r)r=r)rrrr_ensure_no_complex_datas     rnumeric) rr7orderrFrGrLallow_ndensure_min_samplesensure_min_features estimatorc # Cst|tjrtdt|} t|to,|dk} t|dd}t|dsHd}d}d}t|drnt|j drnt t 6d d l m }t|d s|j |rtd WdQRXt|j }xt|D]\}}|jd krtt||<q|jdrt t Nd dlm}m}m}m}m}m}m}m}t|||||||||frBd}WdQRXqWt dd|Drntj!|}| r|dk r|jdkrtj"}nd}t|tt#fr|dk r||krd}n|d }|r|$|}|dkrt%d&|| dk rt| tr | }n| j'j(}nd}| dk r,d|nd}t|d r|j)dkr|j*+}|jtdkrt,dd| j D}t-|dkrt%dt./|rt0|t1||||||d}nt2yxt3dt4|dk r*t|jd kr*tj5||d!}|jjd"krt6|d|d#|j$|d$dd%}ntj5|||d&}Wn4t4k rp}zt%d'&||Wdd}~XYnXWdQRXt0||r|j)d krt%d(&||j)dkrt%d)&|| r"|jjd*kr"tjd+td,d-y|$tj"}Wn.t%k r } zt%d.| Wdd} ~ XYnX|sF|j)d/krFt%d0|j)|f|r\t6||d1kd2| d krt7|}!|!| krt%d3|!|j8| |f| d kr|j)d,kr|j8d}"|"| krt%d4|"|j8| |f|rt9|| rtj:|||d5}|S)6a` 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 : str, bool or list/tuple of str, 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 : 'numeric', type, list of type 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 : bool, default=False Whether a forced copy will be triggered. If copy=False, a copy might be triggered by a conversion. force_all_finite : bool or 'allow-nan', default=True Whether to raise an error on np.inf, np.nan, pd.NA in array. The possibilities are: - True: Force all values of array to be finite. - False: accepts np.inf, np.nan, pd.NA in array. - 'allow-nan': accepts only np.nan and pd.NA values in array. Values cannot be infinite. .. versionadded:: 0.20 ``force_all_finite`` accepts the string ``'allow-nan'``. .. versionchanged:: 0.23 Accepts `pd.NA` and converts it into `np.nan` ensure_2d : bool, default=True Whether to raise a value error if array is not 2D. allow_nd : bool, 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. znp.matrix usage is deprecated in 1.0 and will raise a TypeError in 1.2. Please convert to a numpy array with np.asarray. For more information see: https://numpy.org/doc/stable/reference/generated/numpy.matrix.htmlrr7Nr)Fdtypesr[r) is_sparsesparsezWpandas.DataFrame with sparse columns found.It will be converted to a dense numpy array.b)ZIntZUInt) Int8Dtype Int16Dtype Int32Dtype Int64Dtype UInt8Dtype UInt16Dtype UInt32Dtype UInt64DtypeTcss|]}t|tjVqdS)N)rPr6r7)rr7rrr szcheck_array..O)TFz allow-nanzBforce_all_finite should be a bool or "allow-nan". Got {!r} insteadZ Estimatorz by %srr4cSsg|] }|jjqSr)subtyper)rdtrrrrszcheck_array..zPandas DataFrame with mixed sparse extension arrays generated a sparse matrix with object dtype which can not be converted to a scipy sparse matrix.Sparse extension arrays should all have the same numeric type.)rKr7rFrGrerroriu)rr$)r?r@unsafe)ZcastingrF)rr7zComplex data not supported {} zExpected 2D array, got scalar array instead: array={}. 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.zExpected 2D array, got 1D array instead: array={}. 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.ZOUSVzArrays of bytes/strings is being converted to decimal numbers if dtype='numeric'. This behavior is deprecated in 0.24 and will be removed in 1.1 (renaming of 0.26). Please convert your data to numeric values explicitly instead.r )rzRUnable to convert array of bytes/strings into decimal numbers with dtype='numeric'z*Found array with dim %d. %s expected <= 2.z allow-nan)r?zMFound array with %d sample(s) (shape=%s) while a minimum of %d is required%s.zNFound array with %d feature(s) (shape=%s) while a minimum of %d is required%s.)r7r);rPr6rQrrrrfgetattrr\rr ImportErrorZpandas.api.typesrapplyr;r enumerater)r7r4r startswithZpandasrrrrrrrrr<Z result_typerSrrWr=r __class____name__ndimrZto_coosetrrBrCrrcatch_warnings simplefilterrrerArsrZZmay_share_memoryr)#rrKrr7rrFrGrLrrrrZ array_origZ dtype_numericZ dtype_origZ dtypes_origZhas_pd_integer_arrayriZ dtype_iterrrrrrrrrZestimator_namecontextZ unique_dtypesZcomplex_warninge n_samplesZ n_featuresrrrrRsb         (                     rRcCsl|shdg}|dkr ddg}n|dkr6ddg}ndSx,|D]$}t||j}||kr@td |q@WdS) zGRaise a ValueError if X has 64bit indices and accept_large_sparse=FalseZint32rJcolrow)rHrIZbsrindicesindptrNzNOnly sparse matrices with 32-bit integer indices are accepted. Got %s indices.)Z getformatrr7r=)r>rZsupported_indicesZ index_keyskeyZindices_datatyperrrr:s      r) rr7rrFrGrLr multi_outputrr y_numericrc CsP|dkrtdt||||||||| | | |d }t|| | d}t||||fS)a=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 : {ndarray, list, sparse matrix} Input data. y : {ndarray, list, sparse matrix} Labels. accept_sparse : str, bool or list of str, 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. .. versionadded:: 0.20 dtype : 'numeric', type, list of type 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'}, default=None Whether an array will be forced to be fortran or c-style. copy : bool, default=False Whether a forced copy will be triggered. If copy=False, a copy might be triggered by a conversion. force_all_finite : bool 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. .. versionadded:: 0.20 ``force_all_finite`` accepts the string ``'allow-nan'``. .. versionchanged:: 0.23 Accepts `pd.NA` and converts it into `np.nan` ensure_2d : bool, default=True Whether to raise a value error if X is not 2D. allow_nd : bool, default=False Whether to allow X.ndim > 2. multi_output : bool, 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 : bool, 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. 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. Nzy cannot be None) rKrr7rrFrGrLrrrr)rr)r=rR_check_yr~)r>yrKrr7rrFrGrLrrrrrrrrr check_X_yMs$t rcCsT|rt|ddddd}nt|dd}t|t||rP|jjdkrP|tj}|S)z4Isolated part of check_X_y dedicated to y validationrHTFN)rKrGrLr7)rr) rR column_or_1drArr7r)rWr6rS)rrrrrrrs  r)rcCsrt|}t|}t|dkr*t|St|dkr`|ddkr`|rVtjdtddt|Std |dS)avRavel column or 1d numpy array, else raises an error. Parameters ---------- y : array-like Input data. warn : bool, default=False To control display of warnings. Returns ------- y : ndarray Output data. Raises ------- ValueError If `y` is not a 1D array or a 2D array with a single row or column. rr zA column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().)rz9y should be a 1d array, got an array of shape {} instead.N) r6rerZrZravelrrrr=r)rrrZrrrrs     rcCsV|dks|tjkrtjjjSt|tjr4tj|St|tjjrF|Std|dS)aTurn seed into a np.random.RandomState instance Parameters ---------- seed : None, int or instance of RandomState If seed is None, return the RandomState singleton used by np.random. If seed is an int, return a new RandomState instance seeded with seed. If seed is already a RandomState instance, return it. Otherwise raise ValueError. Nz=%r cannot be used to seed a numpy.random.RandomState instance) r6randomZmtrandZ_randrPrqrrZ RandomStater=)seedrrrcheck_random_states    rcCs|t|jjkS)a(Check whether the estimator's fit method supports the given parameter. Parameters ---------- estimator : object An estimator to inspect. parameter : str The searched parameter. Returns ------- is_parameter : bool Whether the parameter was found to be a named parameter of the estimator's fit method. Examples -------- >>> from sklearn.svm import SVC >>> from sklearn.utils.validation import has_fit_parameter >>> has_fit_parameter(SVC(), "sample_weight") True )rror)rZ parameterrrrhas_fit_parameter)srg|=)tol raise_warningraise_exceptioncCs|jdks|jd|jdkr.td|jt|rj||j}|jdkrT|}t t |j |k}ntj ||j|d}|s|rtd|rt jddd t|rd |j}td ||j|}nd ||j}|S) aMake sure that array is 2D, square and symmetric. If the array is not symmetric, then a symmetrized version is returned. Optionally, a warning or exception is raised if the matrix is not symmetric. Parameters ---------- array : {ndarray, sparse matrix} Input object to check / convert. Must be two-dimensional and square, otherwise a ValueError will be raised. tol : float, default=1e-10 Absolute tolerance for equivalence of arrays. Default = 1E-10. raise_warning : bool, default=True If True then raise a warning if conversion is required. raise_exception : bool, default=False If True then raise an exception if array is not symmetric. Returns ------- array_sym : {ndarray, sparse matrix} Symmetrized version of the input array, i.e. the average of array and array.transpose(). If sparse, then duplicate entries are first summed and zeros are eliminated. r rrz3array must be 2-dimensional and square. shape = {0})rHrIrJ)atolzArray must be symmetriczYArray is not symmetric, and will be converted to symmetric by average with its transpose.)rtog?)rrZr=rrBrCTrr6r<absrDallcloserrr)rrrrdiffZ symmetric conversionrrrcheck_symmetricDs*     r)msg all_or_anycstrtd|dkr"d}tds8td|dk rlt|ttfsT|g}|fdd|D}n&tdr}nd dtD}|st |d t j idS) aPerform is_fitted validation for estimator. Checks if the estimator is fitted by verifying the presence of fitted attributes (ending with a trailing underscore) and otherwise raises a NotFittedError with the given message. If an estimator does not set any attributes with a trailing underscore, it can define a ``__sklearn_is_fitted__`` method returning a boolean to specify if the estimator is fitted or not. Parameters ---------- estimator : estimator instance estimator instance for which the check is performed. attributes : str, list or tuple of str, default=None Attribute name(s) given as string or a list/tuple of strings Eg.: ``["coef_", "estimator_", ...], "coef_"`` If `None`, `estimator` is considered fitted if there exist an attribute that ends with a underscore and does not start with double underscore. msg : str, default=None The default error message is, "This %(name)s instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator." For custom messages if "%(name)s" is present in the message string, it is substituted for the estimator name. Eg. : "Estimator, %(name)s, must be fitted before sparsifying". all_or_any : callable, {all, any}, default=all Specify whether all or any of the given attributes must exist. Returns ------- None Raises ------ NotFittedError If the attributes are not found. z{} is a class, not an instance.NzlThis %(name)s instance is not fitted yet. Call 'fit' with appropriate arguments before using this estimator.roz %s is not an estimator instance.csg|]}t|qSr)r\)rattr)rrrrsz#check_is_fitted..__sklearn_is_fitted__cSs$g|]}|dr|ds|qS)___)endswithr)rvrrrrsr) rrdrr\rPrrrvarsrrar)r attributesrrZfittedr)rrcheck_is_fitteds.    rcCsZt|r:|jdkr|}|jjdkr.d}qB|j}n|}|dkrVtd|dS)z Check if there is any negative value in an array. Parameters ---------- X : {array-like, sparse matrix} Input data. whom : str Who passed X to this function. )ZlilZdokrz$Negative values in data passed to %sN)rBrCrrrDsizeminr=)r>ZwhomZX_minrrrcheck_non_negatives    rboth)min_valmax_valinclude_boundariesc Cst||s(t|d|dt|dd}||krNtdt|d|d|dkr\tjntj}|dk r|||rt|d |d |dkrd nd d |d|dkrtjntj }|dk r|||rt|d |d |dkrdndd |d|S)aValidate scalar parameters type and value. Parameters ---------- x : object The scalar parameter to validate. name : str The name of the parameter to be printed in error messages. target_type : type or tuple Acceptable data types for the parameter. min_val : float or int, default=None The minimum valid value the parameter can take. If None (default) it is implied that the parameter does not have a lower bound. max_val : float or int, default=None The maximum valid value the parameter can take. If None (default) it is implied that the parameter does not have an upper bound. include_boundaries : {"left", "right", "both", "neither"}, default="both" Whether the interval defined by `min_val` and `max_val` should include the boundaries. Possible choices are: - `"left"`: only `min_val` is included in the valid interval; - `"right"`: only `max_val` is included in the valid interval; - `"both"`: `min_val` and `max_val` are included in the valid interval; - `"neither"`: neither `min_val` nor `max_val` are included in the valid interval. Returns ------- x : numbers.Number The validated number. Raises ------ TypeError If the parameter's type does not match the desired type. ValueError If the parameter's value violates the given bounds. z must be an instance of z, not r`)leftrightrZneitherz(Unknown value for `include_boundaries`: z. Possible values are: )rrNz == z , must be z>=> )rrz<=<) rPrdrar=reproperatorltlegtge)r]rZ target_typerrrZexpected_include_boundariesZcomparison_operatorrrr check_scalars6 **rc Cs~t|}|jtjk}d}|r"dnd}|r.dnd}|r:dnd}t|stt|}tt |}|||krt d|||rt d||t t |}|} | d krt d | nj|} | | | kr| | krt d | | n2| d kr:|r.t d | | t d ||d k<d |k||| k@} | rz|rrt d d|t d || <|S)aCheck the eigenvalues of a positive semidefinite (PSD) matrix. Checks the provided array of PSD matrix eigenvalues for numerical or conditioning issues and returns a fixed validated version. This method should typically be used if the PSD matrix is user-provided (e.g. a Gram matrix) or computed using a user-provided dissimilarity metric (e.g. kernel function), or if the decomposition process uses approximation methods (randomized SVD, etc.). It checks for three things: - that there are no significant imaginary parts in eigenvalues (more than 1e-5 times the maximum real part). If this check fails, it raises a ``ValueError``. Otherwise all non-significant imaginary parts that may remain are set to zero. This operation is traced with a ``PositiveSpectrumWarning`` when ``enable_warnings=True``. - that eigenvalues are not all negative. If this check fails, it raises a ``ValueError`` - that there are no significant negative eigenvalues with absolute value more than 1e-10 (1e-6) and more than 1e-5 (5e-3) times the largest positive eigenvalue in double (simple) precision. If this check fails, it raises a ``ValueError``. Otherwise all negative eigenvalues that may remain are set to zero. This operation is traced with a ``PositiveSpectrumWarning`` when ``enable_warnings=True``. Finally, all the positive eigenvalues that are too small (with a value smaller than the maximum eigenvalue multiplied by 1e-12 (2e-7)) are set to zero. This operation is traced with a ``PositiveSpectrumWarning`` when ``enable_warnings=True``. Parameters ---------- lambdas : array-like of shape (n_eigenvalues,) Array of eigenvalues to check / fix. enable_warnings : bool, default=False When this is set to ``True``, a ``PositiveSpectrumWarning`` will be raised when there are imaginary parts, negative eigenvalues, or extremely small non-zero eigenvalues. Otherwise no warning will be raised. In both cases, imaginary parts, negative eigenvalues, and extremely small non-zero eigenvalues will be set to zero. Returns ------- lambdas_fixed : ndarray of shape (n_eigenvalues,) A fixed validated copy of the array of eigenvalues. Examples -------- >>> from sklearn.utils.validation import _check_psd_eigenvalues >>> _check_psd_eigenvalues([1, 2]) # nominal case array([1, 2]) >>> _check_psd_eigenvalues([5, 5j]) # significant imag part Traceback (most recent call last): ... ValueError: There are significant imaginary parts in eigenvalues (1 of the maximum real part). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix. >>> _check_psd_eigenvalues([5, 5e-5j]) # insignificant imag part array([5., 0.]) >>> _check_psd_eigenvalues([-5, -1]) # all negative Traceback (most recent call last): ... ValueError: All eigenvalues are negative (maximum is -1). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix. >>> _check_psd_eigenvalues([5, -1]) # significant negative Traceback (most recent call last): ... ValueError: There are significant negative eigenvalues (0.2 of the maximum positive). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix. >>> _check_psd_eigenvalues([5, -5e-5]) # insignificant negative array([5., 0.]) >>> _check_psd_eigenvalues([5, 4e-12]) # bad conditioning (too small) array([5., 0.]) gh㈵>g{Gzt?g|=gư>g-q=gH׊>zThere are significant imaginary parts in eigenvalues (%g of the maximum real part). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix.zThere are imaginary parts in eigenvalues (%g of the maximum real part). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix. Only the real parts will be kept.rzAll eigenvalues are negative (maximum is %g). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix.zThere are significant negative eigenvalues (%g of the maximum positive). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix.zThere are negative eigenvalues (%g of the maximum positive). Either the matrix is not PSD, or there was an issue while computing the eigendecomposition of the matrix. Negative eigenvalues will be replaced with 0.zBadly conditioned PSD matrix spectrum: the largest eigenvalue is more than %g times the smallest. Small eigenvalues will be replaced with 0.r)r6rr7rSZisrealr<rimagmaxrealr=rrr rr;) ZlambdasZenable_warningsZis_double_precisionZsignificant_imag_ratioZsignificant_neg_ratioZsignificant_neg_valueZsmall_pos_ratioZ max_imag_absZ max_real_absZmax_eigZmin_eigZtoo_small_lambdasrrr_check_psd_eigenvalues9s\R              rcCst|}|dk r&|tjtjgkr&tj}|dkr>tj||d}nxt|tjr\tj|||d}nZ|dkrptjtjg}t |dd|d|d}|j dkrt d|j |fkrt d |j |f|S) a Validate sample weights. Note that passing sample_weight=None will output an array of ones. Therefore, in some cases, you may want to protect the call with: if sample_weight is not None: sample_weight = _check_sample_weight(...) Parameters ---------- sample_weight : {ndarray, Number or None}, shape (n_samples,) Input sample weights. X : {ndarray, list, sparse matrix} Input data. dtype : dtype, default=None dtype of the validated `sample_weight`. If None, and the input `sample_weight` is an array, the dtype of the input is preserved; otherwise an array with the default numpy dtype is be allocated. If `dtype` is not one of `float32`, `float64`, `None`, the output will be of dtype `float64`. copy : bool, default=False If True, a copy of sample_weight will be created. Returns ------- sample_weight : ndarray of shape (n_samples,) Validated sample weight. It is guaranteed to be "C" contiguous. N)r7FrN)rKrLr7rrFrz)Sample weights must be 1D array or scalarz'sample_weight.shape == {}, expected {}!)rsr6rTrSZonesrPrqNumberfullrRrr=rZr)Z sample_weightr>r7rFrrrr_check_sample_weights.    rHz>& .>cCst|rjt|rj|}|}||t|j|joht|j|johtj|j |j ||dSt|st|stj||||dSt ddS)aCCheck allclose for sparse and dense data. Both x and y need to be either sparse or dense, they can't be mixed. Parameters ---------- x : {array-like, sparse matrix} First array to compare. y : {array-like, sparse matrix} Second array to compare. rtol : float, default=1e-7 Relative tolerance; see numpy.allclose. atol : float, default=1e-9 absolute tolerance; see numpy.allclose. Note that the default here is more tolerant than the default for numpy.testing.assert_allclose, where atol=0. )rtolrzFCan only compare two sparse matrices, not a sparse matrix and an arrayN) rBrCrZsum_duplicatesr6 array_equalrrrrDr=)r]rrrrrr_allclose_dense_sparse&srcCsjddlm}i}xT|D]H\}}t|r:t|t|krD|||<qt|||<||||||<qW|S)aCheck and validate the parameters passed during `fit`. Parameters ---------- X : array-like of shape (n_samples, n_features) Data array. fit_params : dict Dictionary containing the parameters passed at fit. indices : array-like of shape (n_samples,), default=None Indices to be selected if the parameter has the same size as `X`. Returns ------- fit_params_validated : dict Validated parameters. We ensure that the values support indexing. r)_safe_indexing)rrr(r^rsr)r>Z fit_paramsrrZfit_params_validatedZ param_keyZ param_valuerrr_check_fit_paramsMs   rcCsd}t|drtj|jtd}|dks2t|dkr6dStddtdd|DD}t|dks||dd s|dd kst d |d t dS|dd kr|SdS) afGet feature names from X. Support for other array containers should place its implementation here. Parameters ---------- X : {ndarray, dataframe} of shape (n_samples, n_features) Array container to extract feature names. - pandas dataframe : The columns will be considered to be feature names. If the dataframe contains non-string feature names, `None` is returned. - All other array containers will return `None`. Returns ------- names: ndarray or None Feature names of `X`. Unrecognized array containers will return `None`. Ncolumns)r7rcss|] }|jVqdS)N)rc)rtrrrrsz%_get_feature_names..css|]}t|VqdS)N)ra)rrrrrrsrrzrfzVFeature names only support names that are all strings. Got feature names with dtypes: z!. An error will be raised in 1.2.) r\r6rerr4rsortedrrrrr)r>Z feature_namestypesrrr_get_feature_namesus  &  rcCst|dd}t|dd}|dk rztj|td}|dk rJt||sJtd|dk rvt||krvtd|dt||S|dk r|S|dkrtdtjd d t|DtdS) aoGet output feature names for transformation. Parameters ---------- input_features : array-like of str or None, default=None Input features. - If `input_features` is `None`, then `feature_names_in_` is used as feature names in. If `feature_names_in_` is not defined, then names are generated: `[x0, x1, ..., x(n_features_in_)]`. - If `input_features` is an array-like, then `input_features` must match `feature_names_in_` if `feature_names_in_` is defined. Returns ------- feature_names_in : ndarray of str Feature names in. feature_names_in_Nn_features_in_)r7z0input_features is not equal to feature_names_in_z?input_features should have length equal to number of features (z), got z7Unable to generate feature names without n_features_in_cSsg|]}d|qS)r]r)rrrrrrsz+_check_feature_names_in..)rr6rer4rr=rrange)rZinput_featuresrrrrr_check_feature_names_ins    r)N)FN)F)F)F)FF)N)F)NF)rr)N)N)A__doc__ functoolsrrrqrnumpyr6Z scipy.sparserrBinspectrrrZnumpy.core.numericrrw contextlibrfixesr r rr r5 exceptionsr rrrSrTZfloat16Z FLOAT_DTYPESr0rArErXr^rnrsryr~rrrrrRrrrrrrrr<rrrrrrrrrrrrrs        6 # ;5#f A } )=H N . @ ' (0