B \ J@sddlZddlZddlmZmZmZmZddlm Z m Z m Z ddl m Z ddlmZddlmZdd lmZdd lmZedZd d ZGd ddeeeZdS)N) BaseEstimatorMetaEstimatorMixinRegressorMixinclone)check_random_state check_arraycheck_consistent_length)sample_without_replacement)check_is_fitted)LinearRegression)has_fit_parameter)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. r rinf)floatmax_EPSILONabsnpceillog)Z n_inliers n_samples min_samplesZ probabilityZ inlier_ratioZnomZdenomr:lib/python3.7/site-packages/sklearn/linear_model/ransac.py_dynamic_max_trialss rc @sReZdZdZddddddejejejdddf ddZddd Zd d Zd d Z dS)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. More information can be found in the general documentation of linear models. A detailed description of the algorithm can be found in the documentation of the ``linear_model`` sub-package. Read more in the :ref:`User Guide `. Parameters ---------- base_estimator : object, optional 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 `base_estimator` is None, then ``base_estimator=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]), optional 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 `base_estimator`. By default a ``sklearn.linear_model.LinearRegression()`` estimator is assumed and `min_samples` is chosen as ``X.shape[1] + 1``. residual_threshold : float, optional 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`. is_data_valid : callable, optional 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, optional 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, optional Maximum number of iterations for random sample selection. max_skips : int, optional 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, optional Stop iteration if at least this number of inliers are found. stop_score : float, optional Stop iteration if score is greater equal than this threshold. stop_probability : float in range [0, 1], optional 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 : string, callable, optional, default "absolute_loss" String inputs, "absolute_loss" and "squared_loss" are supported which find the absolute loss and squared loss 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. random_state : int, RandomState instance or None, optional, default None The generator used to initialize the centers. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Attributes ---------- estimator_ : object Best fitted model (copy of the `base_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 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) # doctest: +ELLIPSIS 0.9885... >>> reg.predict(X[:1,]) array([-31.9417...]) References ---------- .. [1] https://en.wikipedia.org/wiki/RANSAC .. [2] https://www.sri.com/sites/default/files/publications/ransac-publication.pdf .. [3] http://www.bmva.org/bmvc/2009/Papers/Paper355/Paper355.pdf NdgGz? absolute_lossc CsL||_||_||_||_||_||_||_||_| |_| |_ | |_ | |_ dS)N) base_estimatorrresidual_threshold is_data_validis_model_valid max_trials max_skipsstop_n_inliers stop_scorestop_probability random_stateloss) selfr rr!r"r#r$r%r&r'r(r*r)rrr__init__szRANSACRegressor.__init__cCst|dd}t|dd}t|||jdk r8t|j}nt}|jdkrX|jdd}nbd|jkrndkrnnt|j|jd}n0|jdkr|jddkrt d|j}nt d ||jdkrt d |jd|j dks|j dkrt d |j dkrt t |t |}n|j }|jd krP|jdkrFd d}ndd}nN|jdkr||jdkrrdd}ndd}n"t|jr|j}nt d|jt|j}y|j|dWnt k rYnXt|d} t|j} |dk r| st d| |dk rt|}d} tj } d} d}d}d|_d|_d|_|jd}t|}|j\}}d|_|j}x|j|kr |jd7_|j|j|j|jkrPt |||d}||}||}|j!dk r|!||s|jd7_ql|dkr|"||n|j"||||d|j#dk rF|#|||sF|jd7_ql|$|}|||}||k}t%|}|| kr|jd7_ql||}||}||}|&||}|| kr|| krĐql|} |} |} |}|}t'|t(| |||j }| |j)ks| |j*krlPqlW| dkrF|j|j|j|jkr!sz%RANSACRegressor.fit..cSstjt||ddS)Nr )axis)rsumr)r-r.rrrr/#sZ squared_losscSs ||dS)Nrr)r-r.rrrr/(scSstj||dddS)Nrr )r0)rr1)r-r.rrrr/*szEloss should be 'absolute_loss', 'squared_loss' or a callable.Got %s. )r) sample_weightz\%s does not support sample_weight. Samples weights are only used for the calibration itself.)r2zRANSAC 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*).)0rr r rr rshaperr ValueErrorr(r!Zmedianrr*ndimcallablerr)Z set_paramsrtype__name__ZasarrayrZn_skips_no_inliers_Zn_skips_invalid_data_Zn_skips_invalid_model_ZarangeZ n_trials_r$r%r r"fitr#predictr1scoreminrr&r'warningswarnr estimator_Z inlier_mask_)r+Xyr2r rr!Z loss_functionr)Zestimator_fit_has_sample_weightZestimator_nameZn_inliers_bestZ score_bestZinlier_mask_bestZ X_inlier_bestZ y_inlier_bestrZ sample_idxs_r$Z subset_idxsZX_subsetZy_subsetr.Zresiduals_subsetZinlier_mask_subsetZn_inliers_subsetZinlier_idxs_subsetZX_inlier_subsetZy_inlier_subsetZ score_subsetrrrr9s                                            zRANSACRegressor.fitcCst|d|j|S)aKPredict using the estimated model. This is a wrapper for `estimator_.predict(X)`. Parameters ---------- X : numpy array of shape [n_samples, n_features] Returns ------- y : array, shape = [n_samples] or [n_samples, n_targets] Returns predicted values. r?)r r?r:)r+r@rrrr:s zRANSACRegressor.predictcCst|d|j||S)aReturns the score of the prediction. This is a wrapper for `estimator_.score(X, y)`. Parameters ---------- X : numpy array or sparse matrix of shape [n_samples, n_features] Training data. y : array, shape = [n_samples] or [n_samples, n_targets] Target values. Returns ------- z : float Score of the prediction. r?)r r?r;)r+r@rArrrr;s zRANSACRegressor.score)N) r8 __module__ __qualname____doc__rrr,r9r:r;rrrrr7s  cr)Znumpyrr=baserrrrZutilsrrr Z utils.randomr Zutils.validationr r r exceptionsrZspacingrrrrrrrs      "