U 2dW@sddlmZmZddlZddlZddlmZmZm Z m Z ddlm Z ddl m Z mZddlmZddlmZmZd d lmZdd lmZdd lmZmZmZmZmZdd lmZed Z ddZ!Gdddee e eZ"dS))IntegralRealN) BaseEstimatorMetaEstimatorMixinRegressorMixinclone)MultiOutputMixin)check_random_statecheck_consistent_length)sample_without_replacement)check_is_fitted_check_sample_weight)LinearRegression)has_fit_parameter)IntervalOptions StrOptions HasMethodsHidden)ConvergenceWarningcCsj|t|}ttd|}ttd||}|dkr8dS|dkrHtdStttt|t|S)aDetermine number trials such that at least one outlier-free subset is sampled for the given inlier/outlier ratio. Parameters ---------- n_inliers : int Number of inliers in the data. n_samples : int Total number of samples in the data. min_samples : int Minimum number of samples chosen randomly from original data. probability : float Probability (confidence) that one outlier-free sample is generated. Returns ------- trials : int Number of trials. rrinf)floatmax_EPSILONabsnpceillog)Z n_inliers n_samples min_samplesZ probabilityZ inlier_ratioZnomZdenomr"@/tmp/pip-unpacked-wheel-zrfo1fqw/sklearn/linear_model/_ransac.py_dynamic_max_trialss r$c@s^eZdZUdZedddgdgeeddddeed dd ddgeed ddddgedgedgeed ddde ee j hgeed ddde ee j hgeed ddde ee j hgeeddd dgeed dd dge d d hegd gedddge e dhdgd Zeed<dddddde j e j e j dd ddd ddZdddZddZddZddZdS) RANSACRegressoraRANSAC (RANdom SAmple Consensus) algorithm. RANSAC is an iterative algorithm for the robust estimation of parameters from a subset of inliers from the complete data set. Read more in the :ref:`User Guide `. Parameters ---------- estimator : object, default=None Base estimator object which implements the following methods: * `fit(X, y)`: Fit model to given training data and target values. * `score(X, y)`: Returns the mean accuracy on the given test data, which is used for the stop criterion defined by `stop_score`. Additionally, the score is used to decide which of two equally large consensus sets is chosen as the better one. * `predict(X)`: Returns predicted values using the linear model, which is used to compute residual error using loss function. If `estimator` is None, then :class:`~sklearn.linear_model.LinearRegression` is used for target values of dtype float. Note that the current implementation only supports regression estimators. min_samples : int (>= 1) or float ([0, 1]), default=None Minimum number of samples chosen randomly from original data. Treated as an absolute number of samples for `min_samples >= 1`, treated as a relative number `ceil(min_samples * X.shape[0])` for `min_samples < 1`. This is typically chosen as the minimal number of samples necessary to estimate the given `estimator`. By default a ``sklearn.linear_model.LinearRegression()`` estimator is assumed and `min_samples` is chosen as ``X.shape[1] + 1``. This parameter is highly dependent upon the model, so if a `estimator` other than :class:`linear_model.LinearRegression` is used, the user must provide a value. residual_threshold : float, default=None Maximum residual for a data sample to be classified as an inlier. By default the threshold is chosen as the MAD (median absolute deviation) of the target values `y`. Points whose residuals are strictly equal to the threshold are considered as inliers. is_data_valid : callable, default=None This function is called with the randomly selected data before the model is fitted to it: `is_data_valid(X, y)`. If its return value is False the current randomly chosen sub-sample is skipped. is_model_valid : callable, default=None This function is called with the estimated model and the randomly selected data: `is_model_valid(model, X, y)`. If its return value is False the current randomly chosen sub-sample is skipped. Rejecting samples with this function is computationally costlier than with `is_data_valid`. `is_model_valid` should therefore only be used if the estimated model is needed for making the rejection decision. max_trials : int, default=100 Maximum number of iterations for random sample selection. max_skips : int, default=np.inf Maximum number of iterations that can be skipped due to finding zero inliers or invalid data defined by ``is_data_valid`` or invalid models defined by ``is_model_valid``. .. versionadded:: 0.19 stop_n_inliers : int, default=np.inf Stop iteration if at least this number of inliers are found. stop_score : float, default=np.inf Stop iteration if score is greater equal than this threshold. stop_probability : float in range [0, 1], default=0.99 RANSAC iteration stops if at least one outlier-free set of the training data is sampled in RANSAC. This requires to generate at least N samples (iterations):: N >= log(1 - probability) / log(1 - e**m) where the probability (confidence) is typically set to high value such as 0.99 (the default) and e is the current fraction of inliers w.r.t. the total number of samples. loss : str, callable, default='absolute_error' String inputs, 'absolute_error' and 'squared_error' are supported which find the absolute error and squared error per sample respectively. If ``loss`` is a callable, then it should be a function that takes two arrays as inputs, the true and predicted value and returns a 1-D array with the i-th value of the array corresponding to the loss on ``X[i]``. If the loss on a sample is greater than the ``residual_threshold``, then this sample is classified as an outlier. .. versionadded:: 0.18 random_state : int, RandomState instance, default=None The generator used to initialize the centers. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. base_estimator : object, default="deprecated" Use `estimator` instead. .. deprecated:: 1.1 `base_estimator` is deprecated and will be removed in 1.3. Use `estimator` instead. Attributes ---------- estimator_ : object Best fitted model (copy of the `estimator` object). n_trials_ : int Number of random selection trials until one of the stop criteria is met. It is always ``<= max_trials``. inlier_mask_ : bool array of shape [n_samples] Boolean mask of inliers classified as ``True``. n_skips_no_inliers_ : int Number of iterations skipped due to finding zero inliers. .. versionadded:: 0.19 n_skips_invalid_data_ : int Number of iterations skipped due to invalid data defined by ``is_data_valid``. .. versionadded:: 0.19 n_skips_invalid_model_ : int Number of iterations skipped due to an invalid model defined by ``is_model_valid``. .. versionadded:: 0.19 n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- HuberRegressor : Linear regression model that is robust to outliers. TheilSenRegressor : Theil-Sen Estimator robust multivariate regression model. SGDRegressor : Fitted by minimizing a regularized empirical loss with SGD. References ---------- .. [1] https://en.wikipedia.org/wiki/RANSAC .. [2] https://www.sri.com/wp-content/uploads/2021/12/ransac-publication.pdf .. [3] http://www.bmva.org/bmvc/2009/Papers/Paper355/Paper355.pdf Examples -------- >>> from sklearn.linear_model import RANSACRegressor >>> from sklearn.datasets import make_regression >>> X, y = make_regression( ... n_samples=200, n_features=2, noise=4.0, random_state=0) >>> reg = RANSACRegressor(random_state=0).fit(X, y) >>> reg.score(X, y) 0.9885... >>> reg.predict(X[:1,]) array([-31.9417...]) fitscorepredictNrleft)closedrZbothabsolute_error squared_error random_state deprecated) estimatorr!residual_threshold is_data_validis_model_valid max_trials max_skipsstop_n_inliers stop_scorestop_probabilitylossr-base_estimator_parameter_constraintsdgGz?) r!r0r1r2r3r4r5r6r7r8r-r9c CsR||_||_||_||_||_||_||_||_| |_| |_ | |_ | |_ | |_ dSN) r/r!r0r1r2r3r4r5r6r7r-r8r9)selfr/r!r0r1r2r3r4r5r6r7r8r-r9r"r"r#__init__ szRANSACRegressor.__init__c!Cs|tddd}tdd}|j||||fd\}}t|||jdkr^tdt|j|_|jdk rtt |j}nt }|j dkrt |t st d |jd d }nBd |j krd krnnt|j |jd }n|j d kr|j }||jd kr t d |jd |jdkr2tt|t|}n|j}|jd krd|jd krZdd} ndd} n>|jdkr|jd krdd} ndd} nt|jr|j} t|j} z|j| dWnt k rYnXt|d} t|j} |dk r| st d| |dk rt||}d } tj }d}d}d}d}d |_d |_ d |_!|jd }t"|}d |_#|j$}|j#|kr|j#d 7_#|j|j |j!|j%krqt&||| d}||}||}|j'dk r|'||s|j d 7_ qf|dkr|(||n|j(||||d|j)dk rB|)|||sB|j!d 7_!qf|*|}| ||}||k}t+|}|| kr|jd 7_qf||}||}||}|,||} || kr| |krqf|} | }|}|}|}|}t-|t.| |||j/}| |j0ks||j1krfqqf|dkrF|j|j |j!|j%kr|z%RANSACRegressor.fit..cSstjt||ddS)NrZaxis)rsumrrAr"r"r#rC~s r,cSs ||dS)Nrr"rAr"r"r#rCrDcSstj||dddS)NrrrE)rrFrAr"r"r#rCs )r- sample_weightz\%s does not support sample_weight. Samples weights are only used for the calibration itself.)rGzRANSAC skipped more iterations than `max_skips` without finding a valid consensus set. Iterations were skipped because each randomly chosen sub-sample failed the passing criteria. See estimator attributes for diagnostics (n_skips*).zRANSAC could not find a valid consensus set. All `max_trials` iterations were skipped because each randomly chosen sub-sample failed the passing criteria. See estimator attributes for diagnostics (n_skips*).zRANSAC found a valid consensus set but exited early due to skipping more iterations than `max_skips`. See estimator attributes for diagnostics (n_skips*).)5Z_validate_paramsdict_validate_datar r9warningswarn FutureWarningr/rrr! isinstance ValueErrorshaperrr0Zmedianrr8ndimcallabler r-Z set_paramsrtype__name__rrZn_skips_no_inliers_Zn_skips_invalid_data_Zn_skips_invalid_model_ZarangeZ n_trials_r3r4r r1r&r2r(rFr'minr$r7r5r6r estimator_Z inlier_mask_)!r=XyrGZcheck_X_paramsZcheck_y_paramsr/r!r0Z loss_functionr-Zestimator_fit_has_sample_weightZestimator_nameZn_inliers_bestZ score_bestZinlier_mask_bestZ X_inlier_bestZ y_inlier_bestZinlier_best_idxs_subsetr Z sample_idxsr3Z subset_idxsZX_subsetZy_subsetrBZresiduals_subsetZinlier_mask_subsetZn_inliers_subsetZinlier_idxs_subsetZX_inlier_subsetZy_inlier_subsetZ score_subsetr"r"r#r&,sb                                    zRANSACRegressor.fitcCs&t||j|dddd}|j|S)auPredict using the estimated model. This is a wrapper for `estimator_.predict(X)`. Parameters ---------- X : {array-like or sparse matrix} of shape (n_samples, n_features) Input data. Returns ------- y : array, shape = [n_samples] or [n_samples, n_targets] Returns predicted values. FTr@r?reset)r rIrUr()r=rVr"r"r#r(3szRANSACRegressor.predictcCs(t||j|dddd}|j||S)aReturn the score of the prediction. This is a wrapper for `estimator_.score(X, y)`. Parameters ---------- X : (array-like or sparse matrix} of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) or (n_samples, n_targets) Target values. Returns ------- z : float Score of the prediction. FTrX)r rIrUr')r=rVrWr"r"r#r'KszRANSACRegressor.scorecCs dddiiS)NZ _xfail_checksZcheck_sample_weights_invariancez8zero sample_weight is not equivalent to removing samplesr")r=r"r"r# _more_tagsfs zRANSACRegressor._more_tags)N)N)rS __module__ __qualname____doc__rrrrrQrrrrrr:rH__annotations__r>r&r(r'rZr"r"r"r#r%9sb 1     #  r%)#ZnumbersrrrJZnumpyrbaserrrrr utilsr r Z utils.randomr Zutils.validationr r_baserrZutils._param_validationrrrrr exceptionsrspacingrr$r%r"r"r"r#s&      "