
    h$,f                     J   d dl Z d dlZd dlZd dlZd dlmZmZ d dlZd dlZ	d dl
mZ d dlmZmZ d dlmZmZmZ d dlmZ d dlmZ d dlmZ d dlmZ d d	lmZmZ d d
lm Z m!Z!m"Z"m#Z# d dl$m%Z% d dl&m'Z' d dl(m)Z)m*Z* d dl+m,Z,m-Z-m.Z. d dl/m0Z0m1Z1 d dl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQ d dlRmSZS d dlTmUZU d dlVmWZWmXZXmYZY  G d deZ      Z[ G d dee      Z\ G d de      Z] G d de      Z^ G d de      Z_ G d d e      Z` G d! d"e      Za G d# d$e      Zb G d% d&e      Zc G d' d(e      Zd G d) d*e      Ze G d+ d,e\      Zf G d- d.e\      Zg G d/ d0e\      Zh G d1 d2e      Zi G d3 d4e\      Zj G d5 d6e      Zk G d7 d8e      Zl G d9 d:e      Zm G d; d<e\      Zn G d= d>e      Zo G d? d@e      Zp G dA dBe      Zq G dC dDe#      Zr G dE dFer      Zs G dG dHe      Zt G dI dJe       Zu G dK dLe       Zv G dM dNe!      Zw G dO dPe      Zx G dQ dRe      ZydS ZzdT Z{dU Z|dV Z}dW Z~dX ZdY ZdZ Zd[ Zd\ Zd] Zd^ Zd_ Zd` Z G da dbee      Zdc Zdd Zde Zdf Zdg Zdh Zedik(  r e        dj Zdk Zdl Zdm Zdn Zdo Zdp Zy)q    N)IntegralReal)config_context
get_config)BaseEstimatorClassifierMixinOutlierMixin)MiniBatchKMeans)make_multilabel_classification)PCA)ExtraTreesClassifier)ConvergenceWarningSkipTestWarning)LinearRegressionLogisticRegressionMultiTaskElasticNetSGDClassifier)GaussianMixture)KNeighborsRegressor)SVCNuSVC)
_array_apiall_estimators
deprecated)Interval
StrOptions)MinimalClassifierMinimalRegressorMinimalTransformerSkipTestignore_warningsraises)_NotAnArray_set_checking_parameters_yield_all_checkscheck_array_api_input-check_class_weight_balanced_linear_classifier"check_classifier_data_not_an_array<check_classifiers_multilabel_output_format_decision_function2check_classifiers_multilabel_output_format_predict8check_classifiers_multilabel_output_format_predict_proba(check_dataframe_column_names_consistency check_decision_proba_consistencycheck_estimator%check_estimator_get_tags_default_keyscheck_estimators_unfittedcheck_fit_check_is_fittedcheck_fit_score_takes_y%check_methods_sample_order_invariancecheck_methods_subset_invariancecheck_no_attributes_set_in_initcheck_outlier_contaminationcheck_outlier_corruption!check_regressor_data_not_an_arraycheck_requires_y_noneset_random_state)CSR_CONTAINERS)available_if)check_arraycheck_is_fitted	check_X_yc                       e Zd ZdZy)CorrectNotFittedErrorzException class to raise if estimator is used before fitting.

    Like NotFittedError, it inherits from ValueError, but not from
    AttributeError. Used for testing only.
    N)__name__
__module____qualname____doc__     Ilib/python3.12/site-packages/sklearn/utils/tests/test_estimator_checks.pyrA   rA   H   s    rG   rA   c                       e Zd Zd Zd Zy)BaseBadClassifierc                     | S NrF   selfXys      rH   fitzBaseBadClassifier.fitQ       rG   c                 F    t        j                  |j                  d         S Nr   nponesshaperN   rO   s     rH   predictzBaseBadClassifier.predictT   s    wwqwwqz""rG   NrB   rC   rD   rQ   rZ   rF   rG   rH   rJ   rJ   P   s    #rG   rJ   c                   "    e Zd ZddZddZd Zy)ChangesDictc                     || _         y rL   )key)rN   r_   s     rH   __init__zChangesDict.__init__Y   s	    rG   Nc                 0    | j                  ||      \  }}| S rL   _validate_datarM   s      rH   rQ   zChangesDict.fit\       ""1a(1rG   c                 j    t        |      }d| _        t        j                  |j                  d         S )Ni  r   )r=   r_   rV   rW   rX   rY   s     rH   rZ   zChangesDict.predict`   s)    Nwwqwwqz""rG   r   rL   )rB   rC   rD   r`   rQ   rZ   rF   rG   rH   r]   r]   X   s    #rG   r]   c                       e Zd ZddZddZy)SetsWrongAttributec                     || _         y rL   )acceptable_key)rN   rj   s     rH   r`   zSetsWrongAttribute.__init__g   s
    ,rG   Nc                 >    d| _         | j                  ||      \  }}| S rT   wrong_attributerc   rM   s      rH   rQ   zSetsWrongAttribute.fitj   %     ""1a(1rG   rf   rL   rB   rC   rD   r`   rQ   rF   rG   rH   rh   rh   f   s    -rG   rh   c                       e Zd ZddZddZy)ChangesWrongAttributec                     || _         y rL   )rm   )rN   rm   s     rH   r`   zChangesWrongAttribute.__init__q   
    .rG   Nc                 >    d| _         | j                  ||      \  }}| S N   rl   rM   s      rH   rQ   zChangesWrongAttribute.fitt   rn   rG   rf   rL   ro   rF   rG   rH   rq   rq   p   s    /rG   rq   c                       e Zd ZddZy)ChangesUnderscoreAttributeNc                 >    d| _         | j                  ||      \  }}| S ru   )_good_attributerc   rM   s      rH   rQ   zChangesUnderscoreAttribute.fit{   rn   rG   rL   rB   rC   rD   rQ   rF   rG   rH   rx   rx   z   s    rG   rx   c                   .     e Zd ZddZ fdZddZ xZS )RaisesErrorInSetParamsc                     || _         y rL   prN   r   s     rH   r`   zRaisesErrorInSetParams.__init__   	    rG   c                 z    d|v r(|j                  d      }|dk  rt        d      || _        t        |   di |S )Nr   r   zp can't be less than 0rF   )pop
ValueErrorr   super
set_paramsrN   kwargsr   	__class__s      rH   r   z!RaisesErrorInSetParams.set_params   sD    &=

3A1u !9::DFw!+F++rG   c                 0    | j                  ||      \  }}| S rL   rb   rM   s      rH   rQ   zRaisesErrorInSetParams.fit   rd   rG   rf   rL   rB   rC   rD   r`   r   rQ   __classcell__r   s   @rH   r}   r}          ,rG   r}   c                   (    e Zd Z e       fdZddZy)HasMutableParametersc                     || _         y rL   r   r   s     rH   r`   zHasMutableParameters.__init__   r   rG   Nc                 0    | j                  ||      \  }}| S rL   rb   rM   s      rH   rQ   zHasMutableParameters.fit   rd   rG   rL   )rB   rC   rD   objectr`   rQ   rF   rG   rH   r   r      s     rG   r   c                   B    e Zd Zd ej                  d      efdZddZy)HasImmutableParameters*   c                 .    || _         || _        || _        y rL   )r   qr)rN   r   r   r   s       rH   r`   zHasImmutableParameters.__init__   s    rG   Nc                 0    | j                  ||      \  }}| S rL   rb   rM   s      rH   rQ   zHasImmutableParameters.fit   rd   rG   rL   )rB   rC   rD   rV   int32r   r`   rQ   rF   rG   rH   r   r      s    xrxx|v 
rG   r   c                   .     e Zd ZddZ fdZddZ xZS )"ModifiesValueInsteadOfRaisingErrorc                     || _         y rL   r   r   s     rH   r`   z+ModifiesValueInsteadOfRaisingError.__init__   r   rG   c                 h    d|v r|j                  d      }|dk  rd}|| _        t        |   di |S )Nr   r   rF   )r   r   r   r   r   s      rH   r   z-ModifiesValueInsteadOfRaisingError.set_params   s=    &=

3A1uDFw!+F++rG   c                 0    | j                  ||      \  }}| S rL   rb   rM   s      rH   rQ   z&ModifiesValueInsteadOfRaisingError.fit   rd   rG   rf   rL   r   r   s   @rH   r   r      r   rG   r   c                   .     e Zd ZddZ fdZddZ xZS )ModifiesAnotherValuec                      || _         || _        y rL   )ab)rN   r   r   s      rH   r`   zModifiesAnotherValue.__init__   s    rG   c                     d|v r2|j                  d      }|| _        ||j                  d       d| _        t        |   di |S )Nr   r   method2rF   )r   r   r   r   r   )rN   r   r   r   s      rH   r   zModifiesAnotherValue.set_params   sH    &=

3ADFy

3"w!+F++rG   c                 0    | j                  ||      \  }}| S rL   rb   rM   s      rH   rQ   zModifiesAnotherValue.fit   rd   rG   )r   method1rL   r   r   s   @rH   r   r      s    ,rG   r   c                       e Zd Zd Zy)NoCheckinPredictc                 0    | j                  ||      \  }}| S rL   rb   rM   s      rH   rQ   zNoCheckinPredict.fit   rd   rG   Nr{   rF   rG   rH   r   r      s    rG   r   c                       e Zd Zd Zd Zy)NoSparseClassifierc                 x    | j                  ||ddg      \  }}t        j                  |      rt        d      | S )Ncsrcsc)accept_sparseNonsensical Error)rc   spissparser   rM   s      rH   rQ   zNoSparseClassifier.fit   s=    ""1au~"F1;;q>011rG   c                 \    t        |      }t        j                  |j                  d         S rT   r=   rV   rW   rX   rY   s     rH   rZ   zNoSparseClassifier.predict   "    Nwwqwwqz""rG   Nr[   rF   rG   rH   r   r      s    #rG   r   c                       e Zd Zd Zd Zy)CorrectNotFittedErrorClassifierc                 ~    | j                  ||      \  }}t        j                  |j                  d         | _        | S ru   )rc   rV   rW   rX   coef_rM   s      rH   rQ   z#CorrectNotFittedErrorClassifier.fit   s5    ""1a(1WWQWWQZ(
rG   c                 r    t        |        t        |      }t        j                  |j                  d         S rT   )r>   r=   rV   rW   rX   rY   s     rH   rZ   z'CorrectNotFittedErrorClassifier.predict   s*    Nwwqwwqz""rG   Nr[   rF   rG   rH   r   r      s    
#rG   r   c                       e Zd ZddZd Zy)NoSampleWeightPandasSeriesTypeNc                 r    | j                  ||ddd      \  }}ddlm} t        ||      rt	        d      | S )Nr   r   Tr   multi_output	y_numericr   Seriesz>Estimator does not accept 'sample_weight'of type pandas.Series)rc   pandasr   
isinstancer   )rN   rO   rP   sample_weightr   s        rH   rQ   z"NoSampleWeightPandasSeriesType.fit   sL    ""qTT # 
1 	"mV,P  rG   c                 \    t        |      }t        j                  |j                  d         S rT   r   rY   s     rH   rZ   z&NoSampleWeightPandasSeriesType.predict   r   rG   rL   r[   rF   rG   rH   r   r      s    #rG   r   c                       e Zd ZddZd Zy)BadBalancedWeightsClassifierNc                     || _         y rL   )class_weight)rN   r   s     rH   r`   z%BadBalancedWeightsClassifier.__init__   s
    (rG   c                     ddl m} ddlm}  |       j	                  |      }|j
                  } || j                  ||      }| j                  dk(  r|dz  }|| _        | S )Nr   )LabelEncoder)compute_class_weight)classesrP   balanced      ?)sklearn.preprocessingr   sklearn.utilsr   rQ   classes_r   r   )rN   rO   rP   r   r   label_encoderr   r   s           rH   rQ   z BadBalancedWeightsClassifier.fit  sb    66$**1-((+D,=,=wRST 
*CL "
rG   rL   ro   rF   rG   rH   r   r      s    )rG   r   c                       e Zd ZddZd Zy)BadTransformerWithoutMixinNc                 (    | j                  |      }| S rL   rb   rM   s      rH   rQ   zBadTransformerWithoutMixin.fit  s    "rG   c                     t        |      }|S rL   )r=   rY   s     rH   	transformz$BadTransformerWithoutMixin.transform  s    NrG   rL   )rB   rC   rD   rQ   r   rF   rG   rH   r   r     s    rG   r   c                       e Zd Zd Zd Zy)NotInvariantPredictc                 8    | j                  ||ddd      \  }}| S Nr   Tr   rb   rM   s      rH   rQ   zNotInvariantPredict.fit  s-    ""qTT # 
1 rG   c                     t        |      }|j                  d   dkD  r"t        j                  |j                  d         S t        j                  |j                  d         S )Nr   rv   )r=   rX   rV   rW   zerosrY   s     rH   rZ   zNotInvariantPredict.predict%  sH    N771:>771771:&&xx
##rG   Nr[   rF   rG   rH   r   r     s    $rG   r   c                       e Zd Zd Zd Zy)NotInvariantSampleOrderc                 F    | j                  ||ddd      \  }}|| _        | S r   )rc   _XrM   s      rH   rQ   zNotInvariantSampleOrder.fit.  s4    ""qTT # 
1 rG   c                 <   t        |      }t        j                  t        j                  |d      t        j                  | j                  d            r?|| j                  k7  j                         r"t        j                  |j                  d         S |d d df   S )Nr   )axis)r=   rV   array_equivsortr   anyr   rX   rY   s     rH   rZ   zNotInvariantSampleOrder.predict6  sm    N NN27711-rwwtwwQ/GHdgg""$88AGGAJ''AwrG   Nr[   rF   rG   rH   r   r   -  s    	rG   r   c                   &    e Zd ZdZddZddZd Zy)OneClassSampleErrorClassifierzoClassifier allowing to trigger different behaviors when `sample_weight` reduces
    the number of classes to 1.c                     || _         y rL   )raise_when_single_class)rN   r   s     rH   r`   z&OneClassSampleErrorClassifier.__init__F  s
    '>$rG   Nc                    t        ||ddd      \  }}d| _        t        j                  |d      \  | _        }| j                  j
                  d   }|dk  r| j                  rd| _        t        d      |ht        |t        j                        r7t        |      dkD  r)t        j                  t        j                  ||            }|dk  rd| _        t        d	      | S )
Nr   Tr   F)return_inverser      znormal class errorr   )r?   has_single_class_rV   uniquer   rX   r   r   r   ndarraylencount_nonzerobincount)rN   rO   rP   r   
n_classes_s        rH   rQ   z!OneClassSampleErrorClassifier.fitI  s    qTT
1 "'99Qt<q]]((+
>d::%)D"122 $-4]9Ka9O--bkk!].KL
A~)-& !455rG   c                     t        |        t        |      }| j                  r"t        j                  |j
                  d         S t        j                  |j
                  d         S rT   )r>   r=   r   rV   r   rX   rW   rY   s     rH   rZ   z%OneClassSampleErrorClassifier.predict_  sJ    N!!88AGGAJ''wwqwwqz""rG   )FrL   rB   rC   rD   rE   r`   rQ   rZ   rF   rG   rH   r   r   B  s    #?,#rG   r   c                       e Zd Zd Zy)!LargeSparseNotSupportedClassifierc                    | j                  ||dddd      \  }}t        j                  |      r|j                         dk(  r?|j                  j
                  dk(  s|j                  j
                  dk(  rt        d      | S |j                         dv r5d|j                  j
                  |j                  j
                  fvsJ d       | S )N)r   r   cooT)r   accept_large_sparser   r   r  int64z(Estimator doesn't support 64-bit indices)r   r   )
rc   r   r   	getformatrowdtypecolr   indicesindptrrM   s      rH   rQ   z%LargeSparseNotSupportedClassifier.fith  s    ""/ $ # 
1 ;;q>{{}%55;;')QUU[[G-C$%OPP  .0IIOOHHNN'  > >> 
 rG   Nr{   rF   rG   rH   r   r   g  s    rG   r   c                   *    e Zd ZddZddZddZd Zy)SparseTransformerNc                     || _         y rL   sparse_container)rN   r  s     rH   r`   zSparseTransformer.__init__  s
     0rG   c                 F    | j                  |      j                  | _        | S rL   )rc   rX   X_shape_rM   s      rH   rQ   zSparseTransformer.fit  s    ++A.44rG   c                 D    | j                  ||      j                  |      S rL   )rQ   r   rM   s      rH   fit_transformzSparseTransformer.fit_transform  s    xx1~''**rG   c                     t        |      }|j                  d   | j                  d   k7  rt        d      | j	                  |      S )Nrv   zBad number of features)r=   rX   r  r   r  rY   s     rH   r   zSparseTransformer.transform  sA    N771:q))566$$Q''rG   rL   )rB   rC   rD   r`   rQ   r  r   rF   rG   rH   r  r  ~  s    1+(rG   r  c                       e Zd Zd Zd Zy)EstimatorInconsistentForPandasc                     	 ddl m} t        ||      r|j                  d   | _        | S t        |      }|d   | _        | S # t        $ r t        |      }|d   | _        | cY S w xY w)Nr   )	DataFrame)r   r   )rv   r   )r   r  r   ilocvalue_r=   ImportError)rN   rO   rP   r  s       rH   rQ   z"EstimatorInconsistentForPandas.fit  sm    	(!Y'ffTl K  NgK 	AAD'DKK	s   'A A  A$#A$c                 x    t        |      }t        j                  | j                  g|j                  d   z        S rT   )r=   rV   arrayr  rX   rY   s     rH   rZ   z&EstimatorInconsistentForPandas.predict  s-    Nxx
233rG   Nr[   rF   rG   rH   r  r    s     4rG   r  c                   ,     e Zd Zd fd	Zd fd	Z xZS )UntaggedBinaryClassifierc                 t    t         |   |||||       t        | j                        dkD  rt	        d      | S )Nr   Only 2 classes are supported)r   rQ   r   r   r   )rN   rO   rP   	coef_initintercept_initr   r   s         rH   rQ   zUntaggedBinaryClassifier.fit  s9    Aq)^]Ct}}!;<<rG   c                 t    t         |   ||||       t        | j                        dkD  rt	        d      | S )N)rO   rP   r   r   r   r   )r   partial_fitr   r   r   )rN   rO   rP   r   r   r   s        rH   r$  z$UntaggedBinaryClassifier.partial_fit  s;    a1g]St}}!;<<rG   )NNNNN)rB   rC   rD   rQ   r$  r   r   s   @rH   r  r    s     rG   r  c                       e Zd Zd Zy)TaggedBinaryClassifierc                 
    ddiS )Nbinary_onlyTrF   rN   s    rH   
_more_tagsz!TaggedBinaryClassifier._more_tags  s    t$$rG   NrB   rC   rD   r+  rF   rG   rH   r'  r'    s    %rG   r'  c                        e Zd Z fdZ xZS )EstimatorMissingDefaultTagsc                 F    t         |          j                         }|d= |S )N	allow_nan)r   	_get_tagscopy)rN   tagsr   s     rH   r1  z%EstimatorMissingDefaultTags._get_tags  s&    w "'')rG   )rB   rC   rD   r1  r   r   s   @rH   r.  r.    s     rG   r.  c                   $     e Zd Z fdZd Z xZS )RequiresPositiveXRegressorc                     | j                  ||d      \  }}|dk  j                         rt        d      t        |   ||      S )NTr   r   z negative X values not supported!rc   r   r   r   rQ   rN   rO   rP   r   s      rH   rQ   zRequiresPositiveXRegressor.fit  sH    ""1ad";1E;;=?@@w{1a  rG   c                 
    ddiS )Nrequires_positive_XTrF   r*  s    rH   r+  z%RequiresPositiveXRegressor._more_tags      %t,,rG   rB   rC   rD   rQ   r+  r   r   s   @rH   r5  r5        !-rG   r5  c                   $     e Zd Z fdZd Z xZS )RequiresPositiveYRegressorc                     | j                  ||d      \  }}|dk  j                         rt        d      t        |   ||      S )NTr7  r    negative y values not supported!r8  r9  s      rH   rQ   zRequiresPositiveYRegressor.fit  sH    ""1ad";1F<<>?@@w{1a  rG   c                 
    ddiS )Nrequires_positive_yTrF   r*  s    rH   r+  z%RequiresPositiveYRegressor._more_tags  r<  rG   r=  r   s   @rH   r@  r@    r>  rG   r@  c                   $     e Zd Z fdZd Z xZS )PoorScoreLogisticRegressionc                 (    t         |   |      dz   S ru   )r   decision_function)rN   rO   r   s     rH   rH  z-PoorScoreLogisticRegression.decision_function  s    w(+a//rG   c                 
    ddiS )N
poor_scoreTrF   r*  s    rH   r+  z&PoorScoreLogisticRegression._more_tags      d##rG   )rB   rC   rD   rH  r+  r   r   s   @rH   rF  rF    s    0$rG   rF  c                       e Zd Zd Zd Zy)PartialFitChecksNamec                 *    | j                  ||       | S rL   rb   rM   s      rH   rQ   zPartialFitChecksName.fit  s    Aq!rG   c                 V    t        | d       }| j                  |||       d| _        | S )N_fitted)resetT)hasattrrc   rP  )rN   rO   rP   rQ  s       rH   r$  z PartialFitChecksName.partial_fit  s2    D),,Aq.rG   N)rB   rC   rD   rQ   r$  rF   rG   rH   rM  rM    s    rG   rM  c                       e Zd ZdZd Zd Zy)BrokenArrayAPIz=Make different predictions when using Numpy and the Array APIc                     | S rL   rF   rM   s      rH   rQ   zBrokenArrayAPI.fit  rR   rG   c                     t               d   }t        j                  |      \  }}|r|j                  g d      S t	        j
                  g d      S )Narray_api_dispatch)rv   r      )rX  r   rv   )r   r   get_namespaceasarrayrV   r  )rN   rO   enabledxp_s        rH   rZ   zBrokenArrayAPI.predict  sD    ,34((+A::i((88I&&rG   N)rB   rC   rD   rE   rQ   rZ   rF   rG   rH   rT  rT    s    G'rG   rT  c                  6   	 t        j                  d       	 t        j                  d       t	        t
        d      5  t        dt               dd	       d d d        y # t        $ r t        d      w xY w# t        $ r t        d      w xY w# 1 sw Y   y xY w)
Narray_api_compatz-array_api_compat is required to run this testznumpy.array_apiz,numpy.array_api is required to run this testNot equal to tolerancematchrT  T)array_namespacecheck_values)	importlibimport_moduleModuleNotFoundErrorr    r"   AssertionErrorr&   rT  rF   rG   rH   test_check_array_api_inputri    s    H 23G 12 
&>	? 
-		

 
  HFGGH  GEFFG
 
s!   A A7 BA47BBc                      t        t        j                  d            } d}t        t        |      5  t        j
                  |        d d d        t        j                  | d       sJ y # 1 sw Y   "xY w)N
   z&Don't want to call array_function sum!ra  )r#   rV   rW   r"   	TypeErrorsummay_share_memory)	not_arraymsgs     rH    test_not_an_array_array_functionrq    s\    BGGBK(I
2C			% 
y y$/// s   A))A2c                  D     G d dt               } t        d |               y )Nc                   (    e Zd Z ed      d        Zy)btest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethodz=Deprecated for the purpose of testing check_fit_score_takes_yc                     | S rL   rF   rM   s      rH   rQ   zftest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethod.fit  s    KrG   N)rB   rC   rD   r   rQ   rF   rG   rH   $TestEstimatorWithDeprecatedFitMethodrt    s    	S	T	 
U	rG   rv  test)r   r2   )rv  s    rH   4test_check_fit_score_takes_y_works_on_deprecated_fitrx    s    } 
 F$H$JKrG   c                     d} t        t        |       5  t        t               d d d        d} t        t	                      t        t
        |       5  t        t                      d d d        d} t        t
        |       5  t        t                      d d d        t        j                  d      5 }t        t                      d d d        t        D cg c]  }|j                   c}v sJ t        t
        |       5  t        t                      d d d        d} t        t        |       5  t        t                      d d d        d} t        t
        |       5  t        t!                      d d d        	 d	d
lm} d} t        t&        |       5  t        t)                      d d d        d} t        t
        |       5  t        t-                      d d d        d} t        t
        |       5  t        t/                      d d d        d} t        t
        |       5  t        t1                      d d d        t        t3                      d} t        t
        |       5  t        t5                      d d d        t6        j8                  }d}dj;                  ||      } t        t
        |       5  t        t7                      d d d        t<        j8                  }d}dj;                  ||      } t        t
        |       5  t        t=                      d d d        t>        j8                  }d|z  } t        t
        |       5  t        t?                      d d d        t@        j8                  }| d} t        t
        |       5  t        tA                      d d d        d} t        t
        |       5  t        tC                      d d d        d} t        t&        |       5  t        tE                      d d d        tF        D ]  }t        tI        |              t        tK                      t        tK        d             t        tM                      t        tO                      t        tQ                      d} t        t&        |       5  t        tS                      d d d        t        tU                      y # 1 sw Y   xY w# 1 sw Y   txY w# 1 sw Y   RxY w# 1 sw Y   -xY wc c}w # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# t*        $ r Y w xY w# 1 sw Y   qxY w# 1 sw Y   OxY w# 1 sw Y   -xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   nxY w# 1 sw Y   9xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w)NzPassing a class was deprecatedra  zXParameter 'p' of estimator 'HasMutableParameters' is of type object which is not allowedz>get_params result does not match what was passed to set_paramsTrecordzobject has no attribute 'fit'Did not raiser   r   zkEstimator NoSampleWeightPandasSeriesType raises error if 'sample_weight' parameter is of type pandas.SerieszCEstimator NoCheckinPredict doesn't check for NaN and inf in predictz)Estimator changes __dict__ during predictzrEstimator ChangesWrongAttribute should not change or mutate  the parameter wrong_attribute from 0 to 1 during fit.zEstimator adds public attribute\(s\) during the fit method. Estimators are only allowed to add private attributes either started with _ or ended with _ but wrong_attribute addedrZ   zY{method} of {name} is not invariant when applied to a datasetwith different sample order.)methodnamez={method} of {name} is not invariant when applied to a subset.z;Estimator %s doesn't seem to fail gracefully on sparse datazu failed when fitted on one label after sample_weight trimming. Error message is not explicit, it should have 'class'.ztEstimator LargeSparseNotSupportedClassifier doesn't seem to support \S{3}_64 matrix, and is not failing gracefully.*r   r  g{Gz?)CrB  )+r"   rl  r.   r   r   rh  r   r   warningscatch_warningsr}   UserWarningcategoryr   AttributeErrorr   rJ   r   r   r   r   r  r   r]   rq   rx   rh   r   rB   formatr   r   r   r   r  r;   r  r   r   r'  r5  r@  rF  )rp  recordsrecr   r~  r}  csr_containers          rH   test_check_estimatorr  #  s   
 +C			%   	& 
 *,-	c	* 0,./0 KC	c	* >:<=>		 	 	- 2.0127;C3<<;;;;	c	* 0,./0 *C	c	* )() C	c	* -)+,-
!A 	 Jc* 	>:<=	>
 PC	c	* ,(*+, 6C	c	* '&'
	@  
c	* 1-/01.01	,  
c	* .*,-. #++DF	'fFf&  
c	* 3/123 ''DFJ
R
RD S C 
c	* /+-./ &&D
G$
NC	c	* .*,-. )11D&  	 
 
c	* 95789
	D  
c	* =9;<= )C	
#	& 40234 ( K)=IJK
 &()&./')* *,-.01 -C	
#	& 62456 /12I   0 0> >2 2;0 0) )- -	> 	> , ,
' '1 1. .3 3/ /
. .9 9= =
4 4$6 6s  SSS%3S2S?T1T T=T8 T+*T8 U4U#U"%U/7U<	V	VV#<V0+V=W
SS"%S/2S<TTT(+T50T8 8	UUUU"U,/U9<V	VV #V-0V:=W
Wc                      t        j                  g d      } t        t              5  t	        dd|        d d d        t        j                  g d      } t	        dd|        y # 1 sw Y   .xY w)N)        r   g      ?       @rv   r   )r  r   r   r  )rV   r  r"   rh  r7   )decisions    rH   test_check_outlier_corruptionr    sW    xx,-H		 1 Ax01 xx,-HQ8,	1 1s   A""A+c                  t    t        t        d      5  t        t                      d d d        y # 1 sw Y   y xY w)Nz.*fit_transform.*)r"   r  r.   r   rF   rG   rH   )test_check_estimator_transformer_no_mixinr    s.    	 3	4 62456 6 6s   .7c                     ddl m}   |        }t        t        t        t
        t        t        fD ]  }t        t              5   |       }t        |       t        |       t        j                  |      }t        |       d d d        t        j                        k(  sJ t        t              5   |       }t        |       t        |       |j                  |j                   dz   |j"                         t        j                  |      }t        |       d d d        |t        j                  |      k(  rJ  y # 1 sw Y   xY w# 1 sw Y   3xY w)Nr   )	load_iris)r  rk  )sklearn.datasetsr  r   r   r   r   r   r
   r!   r   r$   r:   joblibhashr.   rQ   datatarget)r  iris	Estimatorestold_hashs        rH   test_check_estimator_clonesr    s   *;D 	 ,	 &89 	!+C$S)S!{{3'HC 	! 6;;s++++ &89 	!+C$S)S!GGDIINDKK0{{3'HC 	! 6;;s++++3,	! 	!	! 	!s   >D?2A'E?E	E	c                      d} t        t        |       5  t        dt                      d d d        t        dt	                      y # 1 sw Y   xY w)Nr|  ra  	estimator)r"   rh  r0   r   r   rp  s    rH   test_check_estimators_unfittedr    sJ     C	c	* E!+/A/CDE
 k+J+LME Es   AAc                      G d dt               }  G d dt               } G d dt               }d}t        t        |      5  t        d	 |               d d d        d
}t        t        |      5  t        d	 |              d d d        t        d	 |              t        d      5  t        d	 |       j                  d             d d d        y # 1 sw Y   ~xY w# 1 sw Y   ]xY w# 1 sw Y   y xY w)Nc                       e Zd Zd Zy)Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSetc                     d | _         y rL   )you_should_not_set_this_r*  s    rH   r`   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSet.__init__  s
    ,0D)rG   NrB   rC   rD   r`   rF   rG   rH    NonConformantEstimatorPrivateSetr    s    	1rG   r  c                       e Zd ZddZy)Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSetNc                      y rL   rF   )rN   you_should_set_this_s     rH   r`   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSet.__init__  s    rG   rL   r  rF   rG   rH    NonConformantEstimatorNoParamSetr    s    	rG   r  c                       e Zd ZddiZy)Otest_check_no_attributes_set_in_init.<locals>.ConformantEstimatorClassAttributefooTN)rB   rC   rD   9_ConformantEstimatorClassAttribute__metadata_request__fitrF   rG   rH   !ConformantEstimatorClassAttributer    s    #($-rG   r  zEstimator estimator_name should not set any attribute apart from parameters during init. Found attributes \['you_should_not_set_this_'\].ra  estimator_namezPEstimator estimator_name should store all parameters as an attribute during initT)enable_metadata_routing)r  )r   r"   rh  r5   r  r   set_fit_request)r  r  r  rp  s       rH   $test_check_no_attributes_set_in_initr    s    1= 1= 0M 0
	= 
 
c	* 
'>@	

	  
c	* 
'>@	

 $;= 
	5 
'-/??D?I	

 
+
 

 

 
s$   C.C%"C(CC%(C1c                  `    t        d      } t        |        t        d      } t        |        y )Nprecomputed)kernel)metric)r   r.   r   )r  s    rH   test_check_estimator_pairwiser    s*    
 ]
#CC ]
3CCrG   c                  x    t        t        d      5  t        dt                      d d d        y # 1 sw Y   y xY wNr`  ra  r  )r"   rh  r(   r  rF   rG   rH   'test_check_classifier_data_not_an_arrayr  )  s3    	&>	? 
*<>	

 
 
   09c                  x    t        t        d      5  t        dt                      d d d        y # 1 sw Y   y xY wr  )r"   rh  r8   r  rF   rG   rH   &test_check_regressor_data_not_an_arrayr  0  s3    	&>	? 
)<>	

 
 
r  c                      t               } d}t        t        |      5  t        | j                  j
                  |        d d d        t               } t        | j                  j
                  |        y # 1 sw Y   4xY w)NzjEstimatorMissingDefaultTags._get_tags\(\) is missing entries for the following default tags: {'allow_nan'}ra  )r.  r"   rh  r/   r   rB   r   )r  err_msgs     rH   *test_check_estimator_get_tags_default_keysr  7  so    +-I	:  
g	. W-i.A.A.J.JIVW #$I))*=*=*F*F	RW Ws   !A22A;c                     d} t        t        |       5  t        dt                      d d d        t        dt	                      t               }t        |j                  j                  |       d|_        d} t        t        |       5  t        |j                  j                  |       d d d        y # 1 sw Y   xY w# 1 sw Y   y xY w)Nz+Estimator does not have a feature_names_in_ra  r  z;Docstring that does not document the estimator's attributeszNEstimator LogisticRegression does not document its feature_names_in_ attribute)	r"   r   r,   rJ   rM  r   r   rB   rE   )r  lrs     rH   -test_check_dataframe_column_names_consistencyr  E  s    ;G	
'	* X01ACTCVWX,-=?S?UV		B,R\\-B-BBGNBJX  

'	* L01F1FKL LX XL Ls   B3	!B?3B<?Cc                       e Zd Zd Zd Zd Zy)_BaseMultiLabelClassifierMockc                     || _         y rL   response_output)rN   r  s     rH   r`   z&_BaseMultiLabelClassifierMock.__init__V  rs   rG   c                     | S rL   rF   rM   s      rH   rQ   z!_BaseMultiLabelClassifierMock.fitY  rR   rG   c                 
    ddiS )N
multilabelTrF   r*  s    rH   r+  z(_BaseMultiLabelClassifierMock._more_tags\  rK  rG   N)rB   rC   rD   r`   rQ   r+  rF   rG   rH   r  r  U  s    /$rG   r  c            	         d\  } }}t        | d|dddd      \  }}|| d  } G d d	t              } ||j                         
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||d d d df   
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||j                  t        j                        
      }d}t        t        |      5  t        |j                  j                  |       d d d        y # 1 sw Y   xY w# 1 sw Y   xxY w# 1 sw Y   y xY w)Nd         r   rX  2   Tr   	n_samples
n_features	n_classesn_labelslengthallow_unlabeledrandom_statec                       e Zd Zd Zy)\test_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredictc                     | j                   S rL   r  rY   s     rH   rZ   zdtest_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredict.predictn      '''rG   N)rB   rC   rD   rZ   rF   rG   rH   MultiLabelClassifierPredictr  m      	(rG   r  r  zdMultiLabelClassifierPredict.predict is expected to output a NumPy array. Got <class 'list'> instead.ra  zbMultiLabelClassifierPredict.predict outputs a NumPy array of shape \(25, 4\) instead of \(25, 5\).zTMultiLabelClassifierPredict.predict does not output the same dtype than the targets.)r   r  tolistr"   rh  r*   r   rB   astyperV   float64)	r  	test_size	n_outputsr]  rP   y_testr  clfr  s	            rH   7test_check_classifiers_multilabel_output_format_predictr  `  sb   &0#Iy))DAq 	z{^F(&C (
 &fmmo
FC	4  
g	. X:3==;Q;QSVWX &fQVn
EC	1  
g	. X:3==;Q;QSVWX &fmmBJJ6O
PC	#  
g	. X:3==;Q;QSVWX X!X XX XX Xs$   !D5)!E!E5D>E
Ec            	         d\  } }}t        | d|dddd      \  }}|| d  } G d d	t              }t        D ][  } | ||      
      }d|j                   d}	t	        t
        |	      5  t        |j                  j                  |       d d d        ]  ||j                         
      }d| d| d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        |      D cg c]  }t        j                  |       }
} ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        |      D cg c]6  }t        j                  |j                  d   dft        j                        8 }
} ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        |      D cg c]6  }t        j                  |j                  d   dft        j                         8 }
} ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d         ||d d d df   
      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        j"                  |t        j                        }
 ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d         ||dz  
      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        y # 1 sw Y   QxY w# 1 sw Y   xY wc c}w # 1 sw Y   HxY wc c}w # 1 sw Y   xY wc c}w # 1 sw Y   NxY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   y xY w)Nr  r   rX  r  Tr   r  c                       e Zd Zd Zy)gtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProbac                     | j                   S rL   r  rY   s     rH   predict_probazutest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProba.predict_proba  r  rG   N)rB   rC   rD   r  rF   rG   rH    MultiLabelClassifierPredictProbar    r  rG   r  r  zUnknown returned type .*zZ.* by MultiLabelClassifierPredictProba.predict_proba. A list or a Numpy array is expected.ra  zWhen MultiLabelClassifierPredictProba.predict_proba returns a list, the list should be of length n_outputs and contain NumPy arrays. Got length of z instead of .zWhen MultiLabelClassifierPredictProba.predict_proba returns a list, this list should contain NumPy arrays of shape \(n_samples, 2\). Got NumPy arrays of shape \(25, 5\) instead of \(25, 2\).)rX   r  zwWhen MultiLabelClassifierPredictProba.predict_proba returns a list, it should contain NumPy arrays with floating dtype.zWhen MultiLabelClassifierPredictProba.predict_proba returns a list, each NumPy array should contain probabilities for each class and thus each row should sum to 1r  zWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, the expected shape is \(n_samples, n_outputs\). Got \(25, 4\) instead of \(25, 5\).)r  znWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, the expected data type is floating.r  zWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, this array is expected to provide probabilities of the positive class and should therefore contain values between 0 and 1.)r   r  r;   rB   r"   r   r+   r   r  rh  rangerV   	ones_likerW   rX   r  r  
zeros_like)r  r  r  r]  rP   r  r  r  r  r  r  s              rH   =test_check_classifiers_multilabel_output_format_predict_probar    s   &0#Iy))DAq 	z{^F(+H ( ( .}V?TU&}'='=&> ?" " 	
 Jg. 	D&&	 	 +6==?
KC	K|I;a	9 
 
g	. 
@MM""	

 6;95EFr||F+FOF
*?
KC	A 
 
g	. 
@MM""	

 FK9EU@Av||A*"((;O  +?
KC	>  
g	. 
@MM""	

 HMYGWBCv||A*"**=O  +?
KC	) 
 
g	. 
@MM""	

 +6!SbS&>
JC	" 
 
g	. 
@MM""	

 mmF"((;O
*?
KC	6  
g	. 
@MM""	

 +6C<
HC	O 
 
g	. 
@MM""	

 
y	 	
 
 G
 

 

 

 

 

 
sr   *!M>!N<N6!N,;N*!N/;;N<!O"!O!O!O'>N	NN'/N9OOO$'O0c            	      x   d\  } }}t        | d|dddd      \  }}|| d  } G d d	t              } ||j                         
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||d d d df   
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||
      }d}t        t        |      5  t        |j                  j                  |       d d d        y # 1 sw Y   xY w# 1 sw Y   [xY w# 1 sw Y   y xY w)Nr  r   rX  r  Tr   r  c                       e Zd Zd Zy)otest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunctionc                     | j                   S rL   r  rY   s     rH   rH  ztest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunction.decision_function  r  rG   N)rB   rC   rD   rH  rF   rG   rH   $MultiLabelClassifierDecisionFunctionr    r  rG   r  r  zwMultiLabelClassifierDecisionFunction.decision_function is expected to output a NumPy array. Got <class 'list'> instead.ra  r  zMultiLabelClassifierDecisionFunction.decision_function is expected to provide a NumPy array of shape \(n_samples, n_outputs\). Got \(25, 4\) instead of \(25, 5\)z^MultiLabelClassifierDecisionFunction.decision_function is expected to output a floating dtype.)r   r  r  r"   rh  r)   r   rB   )	r  r  r  r]  rP   r  r  r  r  s	            rH   Atest_check_classifiers_multilabel_output_format_decision_functionr    sR   &0#Iy))DAq 	z{^F(/L (
 /v}}
OC	@  
g	. 
DMM""	

 /va"f~
NC	* 
 
g	. 
DMM""	

 /v
FC	'  
g	. 
DMM""	

 
/
 

 

 
s$   !D)!D$.!D0D!$D-0D9c                  |   t         j                  d   } t        |       D cg c]  }|j                  d      rt	        | |      ! }}|D cg c]  }t        j                  |       }}t        j                         }|j                  |       t        j                         }|j                  |       yc c}w c c}w )z1Runs the tests in this file without using pytest.__main__test_N)sysmodulesdir
startswithgetattrunittestFunctionTestCase	TestSuiteaddTestsTextTestRunnerrun)main_moduler~  test_functionsfn
test_casessuiterunners          rH   run_tests_without_pytestr  <  s    ++j)K $??7# 	T"N 
 ;IIB(++B/IJI E	NN:$$&F
JJu
 Js   $B4B9c                  t    d} t        t        |       5  t        dt               d d d        y # 1 sw Y   y xY w)NzIClassifier estimator_name is not computing class_weight=balanced properlyra  r  )r"   rh  r'   r   r  s    rH   2test_check_class_weight_balanced_linear_classifierr  K  s4    
UC	c	* 
5:	

 
 
s   .7c                      t        j                  d      5 } t               }d d d         rJ D ])  }|j                  j                  j                  d      s)J  y # 1 sw Y   <xY w)NTrz  r]  )r  r  r   r   rB   r  )r{  
estimatorsr  s      rH   test_all_estimators_all_publicr  T  sh     
	 	 	- &#%
& : :==))44S999:	& &s   AA&r  c                      t        j                  d      5 } t        t                      d d d        t         D cg c]  }|j
                   c}v sJ y # 1 sw Y   ,xY wc c}w )NTrz  )r  r  r.   r   r   r  )r  r  s     rH   %test_xfail_ignored_in_check_estimatorr  e  sR     
	 	 	- ! !w?s||????! !?s   AA"Ac                      t         rL   )r    r   r   r   r.   )minimal_estimatorsr  s     rH   (test_minimal_class_implementation_checksr  o  s	     NrG   c                       G d dt               } t        t        d      5  t        d | d             d d d        t        d | d             t        d | d	             y # 1 sw Y   0xY w)
Nc                   8    e Zd ZddZd Z ed       d        Zy)1test_check_fit_check_is_fitted.<locals>.Estimatorc                     || _         y rL   behavior)rN   r!  s     rH   r`   z:test_check_fit_check_is_fitted.<locals>.Estimator.__init__{  s	    $DMrG   c                 b    | j                   dk(  r	d| _        | S | j                   dk(  rd| _        | S )N	attributeTr}  )r!  
is_fitted_
_is_fitted)rN   rO   rP   r   s       rH   rQ   z5test_check_fit_check_is_fitted.<locals>.Estimator.fit~  s6    }}+"& K (*"&KrG   c                     | j                   dv S )N>   r}  always-truer   r*  s    rH   <lambda>z:test_check_fit_check_is_fitted.<locals>.Estimator.<lambda>  s    4==4M#M rG   c                 :    | j                   dk(  ryt        | d      S )Nr'  Tr%  )r!  rR  r*  s    rH   __sklearn_is_fitted__zGtest_check_fit_check_is_fitted.<locals>.Estimator.__sklearn_is_fitted__  s    }}-4..rG   N)r#  )rB   rC   rD   r`   rQ   r<   r*  rF   rG   rH   r  r  z  s'    	%	 
M	N	/ 
O	/rG   r  z'passes check_is_fitted before being fitra  r  r'  r   r}  r#  )r   r"   	Exceptionr1   )r  s    rH   test_check_fit_check_is_fittedr,  y  sc    /M /" 
	!J	K R!+y-/PQR k9h+GHk9k+JK	R Rs   A$$A-c                       G d dt               } t        j                  d      5 }t        d |               d d d        D cg c]  }|j                   c}rJ y # 1 sw Y   &xY wc c}w )Nc                       e Zd Zd Zy)-test_check_requires_y_none.<locals>.Estimatorc                 "    t        ||      \  }}y rL   )r?   rM   s      rH   rQ   z1test_check_requires_y_none.<locals>.Estimator.fit  s    Q?DAqrG   Nr{   rF   rG   rH   r  r/    s    	#rG   r  Trz  r  )r   r  r  r9   message)r  r{  r   s      rH   test_check_requires_y_noner2    sb    #M # 
	 	 	- 8k9;78 $**a		****	8 8 +s   AA)A&c                      t         t        t        fD ]g  } t        t	         |                    }t
        |v sJ t        |v sJ  G d d|       }t        t	         |                   }t
        |vsJ t        |vrgJ  y )Nc                       e Zd Zd Zy)>test_non_deterministic_estimator_skip_tests.<locals>.Estimatorc                 
    ddiS )Nnon_deterministicTrF   r*  s    rH   r+  zItest_non_deterministic_estimator_skip_tests.<locals>.Estimator._more_tags  s    +T22rG   Nr,  rF   rG   rH   r  r5    s    3rG   r  )r   r   r   listr%   r3   r4   )r  	all_testsr  s      rH   +test_non_deterministic_estimator_skip_testsr:    s     #$46GH @*3512	4	AAA.);;;	3 	3 *9;78	4IEEE.i???@rG   c            	      "    G d dt         t              }  |        }t        |j                  j                  |      J  G d d|       } |       }d}t        t        |      5  t        |j                  j                  |       ddd       t        t        dd	d
      g|j                  d<    |       }t        |j                  j                  |       t        t        ddd
      t        t        ddd
      t        t        ddd
      t        t        dd	d      g}d}|D ]S  }|g|j                  d<    |       }t        t        |      5  t        |j                  j                  |       ddd       U y# 1 sw Y   xY w# 1 sw Y   lxY w)zHCheck the test for the contamination parameter in the outlier detectors.c                   (    e Zd ZdZddZddZddZy)	Jtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraintz.Outlier detector without parameter validation.c                     || _         y rL   )contamination)rN   r?  s     rH   r`   zStest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.__init__  s
    !.DrG   Nc                     | S rL   rF   )rN   rO   rP   r   s       rH   rQ   zNtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.fit  s    KrG   c                 F    t        j                  |j                  d         S rT   rU   rM   s      rH   rZ   zRtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.predict  s    771771:&&rG   )g?r%  rL   r   rF   rG   rH    OutlierDetectorWithoutConstraintr=    s    <	/		'rG   rB  Nc                   $    e Zd Zd edh      giZy)Gtest_check_outlier_contamination.<locals>.OutlierDetectorWithConstraintr?  autoN)rB   rC   rD   r   _parameter_constraintsrF   rG   rH   OutlierDetectorWithConstraintrD    s    "1Jx4H3I!JrG   rG  zDcontamination constraints should contain a Real Interval constraint.ra  r   g      ?right)closedr?  rv   r  r   leftz<contamination constraint should be an interval in \(0, 0.5\])r	   r   r6   r   rB   r"   rh  r   r   rF  r   )rB  detectorrG  r  incorrect_intervalsintervals         rH    test_check_outlier_contaminationrN    s   

'< 
' 01H&x'9'9'B'BHMUUUK(H K -.HTG	g	. K#H$6$6$?$?JK
 	q#g.M!88I -.H 2 2 ; ;XF 	1a0r1W-q!G,q#f-	 NG' OQ
%<<_M 12N'2 	O'(:(:(C(CXN	O 	OO%K K.	O 	Os   #!E9!F9FF	c                  4    t        d      } t        d|        y)zCheck that in case with some probabilities ties, we relax the
    ranking comparison with the decision function.
    Non-regression test for:
    https://github.com/scikit-learn/scikit-learn/issues/24025
    log_loss)lossr   N)r   r-   )r  s    rH   test_decision_proba_tie_rankingrR    s     :.I$_i@rG   )re  r   r  r  numbersr   r   r  numpyrV   scipy.sparsesparser   sklearnr   r   sklearn.baser   r   r	   sklearn.clusterr
   r  r   sklearn.decompositionr   sklearn.ensembler   sklearn.exceptionsr   r   sklearn.linear_modelr   r   r   r   sklearn.mixturer   sklearn.neighborsr   sklearn.svmr   r   r   r   r   r   sklearn.utils._param_validationr   r   sklearn.utils._testingr   r   r   r    r!   r"   sklearn.utils.estimator_checksr#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   sklearn.utils.fixesr;   sklearn.utils.metaestimatorsr<   sklearn.utils.validationr=   r>   r?   r   rA   rJ   r]   rh   rq   rx   r}   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r'  r.  r5  r@  rF  rM  rT  ri  rq  rx  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rB   r  r  r,  r2  r:  rN  rR  rF   rG   rH   <module>rg     s  
  
   "    . E E + ; % 1 B  , 1 " @ @ @       4 / 5 L LJ # ##- # M  ] "= 	] 	 "= &( 	#* 	#	#&7 	##] #(#4 , $- $ m *"#$5 "#J .( ($4] 4,} %5 %- -!1 --!1 -$"4 $	= 	'] '
&0	LJ3Z-6,D	N+
\


SL $O] $(XVy
x2
j
: z @#L2	+@"3OlArG   