a
    �ù»j¡h  ã                   @   s  d dl Z d dlmZmZ d dlZddlmZmZm	Z	m
Z
mZmZ ddlmZ ddlmZmZmZ ddlmZ ddlmZmZmZmZmZ dd	lmZmZmZmZm Z  dd
l!m"Z" ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) ddl*m+Z+ e ,d¡Z-dd„ Z.G dd„ dee
e	eƒZ/dS )é    N)ÚIntegralÚRealé   )ÚBaseEstimatorÚMetaEstimatorMixinÚMultiOutputMixinÚRegressorMixinÚ_fit_contextÚclone)ÚConvergenceWarning)Úcheck_consistent_lengthÚcheck_random_stateÚget_tags)ÚBunch)Ú
HasMethodsÚIntervalÚOptionsÚ
RealNotIntÚ
StrOptions)ÚMetadataRouterÚMethodMappingÚ_raise_for_paramsÚ_routing_enabledÚprocess_routing)Úsample_without_replacement)Ú_check_method_paramsÚ_check_sample_weightÚ_deprecate_positional_argsÚcheck_is_fittedÚhas_fit_parameterÚvalidate_dataé   )ÚLinearRegressionc                 C   sj   | t |ƒ }ttd| ƒ}ttd||  ƒ}|dkr8dS |dkrHt dƒS tt t t |¡t |¡ ¡ƒƒS )a  Determine 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!   r   Úinf)ÚfloatÚmaxÚ_EPSILONÚabsÚnpÚceilÚlog)Z	n_inliersÚ	n_samplesÚmin_samplesZprobabilityZinlier_ratioZnomÚdenom© r.   úBE:\soccer\ml_env\Lib\site-packages\sklearn/linear_model/_ransac.pyÚ_dynamic_max_trials0   s    r0   c                       sf  e Zd ZU dZeg d¢ƒdgeedddd�eedddd�dgeedddd�dge	dge	dgeedddd�e
eejhƒgeedddd�e
eejhƒgeedddd�e
eejhƒgeedddd�geedddd�ged	d
hƒe	gdgdœZeed< d"dddddejejejdd	ddœdd„Zedd�edd�ddœdd„ƒƒZdd„ Zdd„ Zdd„ Z‡ fd d!„Z‡  ZS )#ÚRANSACRegressora½  RANSAC (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 <ransac_regression>`.

    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
        :class:`~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:`~sklearn.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 <random_state>`.

    Attributes
    ----------
    estimator_ : object
        Final model fitted on the inliers predicted by the "best" model found
        during RANSAC sampling (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] https://bmva-archive.org.uk/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...])

    For a more detailed example, see
    :ref:`sphx_glr_auto_examples_linear_model_plot_ransac.py`
    )ÚfitÚscoreÚpredictNr!   Úleft)Úclosedr   ZbothÚabsolute_errorÚsquared_errorÚrandom_state)Ú	estimatorr,   Úresidual_thresholdÚis_data_validÚis_model_validÚ
max_trialsÚ	max_skipsÚstop_n_inliersÚ
stop_scoreÚstop_probabilityÚlossr9   Ú_parameter_constraintséd   g®Gáz®ï?)r,   r;   r<   r=   r>   r?   r@   rA   rB   rC   r9   c                C   sL   || _ || _|| _|| _|| _|| _|| _|| _|	| _|
| _	|| _
|| _d S ©N)r:   r,   r;   r<   r=   r>   r?   r@   rA   rB   r9   rC   )Úselfr:   r,   r;   r<   r=   r>   r?   r@   rA   rB   rC   r9   r.   r.   r/   Ú__init__!  s    zRANSACRegressor.__init__F)Zprefer_skip_nested_validationz1.7)Úversion)Úsample_weightc          &      K   sè  t || dƒ tddd�}tdd�}t| ||||fd�\}}t||ƒ | jdurZt| jƒ}ntƒ }| jdu rŒt|tƒs|t	dƒ‚|j
d	 d	 }nBd
| j  k r¢d	k r¾n nt | j|j
d
  ¡}n| jd	krÎ| j}||j
d
 krît	d|j
d
  ƒ‚| jdu �rt t |t |¡ ¡¡}	n| j}	| jdk�rH|jd	k�r>dd„ }
ndd„ }
n>| jdk�rt|jd	k�rjdd„ }
ndd„ }
nt| jƒ�r†| j}
t| jƒ}z|j|d� W n t	�y´   Y n0 t|dƒ}t|ƒj}|du�ræ|�sæt	d| ƒ‚|du�rø||d< tƒ �rt| dfi |¤Ž}n6tƒ }ti i i d�|_|du�rJt||ƒ}d|i|j_d	}tj }d}d}d}d}d
| _d
| _ d
| _!|j
d
 }t "|¡}d
| _#| j$}| j#|k �rT|  j#d	7  _#| j| j  | j! | j%k�rÐ�qTt&|||d�}|| }|| }| j'du�r|  '||¡�s|  j d	7  _ �q˜t(||jj|d�}|j||fi |¤Ž | j)du�rn|  )|||¡�sn|  j!d	7  _!�q˜| *|¡}|
||ƒ}||	k}t +|¡}||k �r°|  jd	7  _�q˜|| } ||  }!||  }"t(||jj,| d�}#|j,|!|"fi |#¤Ž}$||k�r|$|k �r�q˜|}|$}|}|!}|"}| }t-|t.|||| j/ƒƒ}|| j0k�sT|| j1k�r˜�qT�q˜|du �rŒ| j| j  | j! | j%k�r‚t	dƒ‚nt	dƒ‚n&| j| j  | j! | j%k�r²t2 3dt4¡ t(||jj|d�}%|j||fi |%¤Ž || _5|| _6| S )a
  Fit estimator using RANSAC algorithm.

        Parameters
        ----------
        X : {array-like, sparse matrix} of shape (n_samples, n_features)
            Training data.

        y : array-like of shape (n_samples,) or (n_samples, n_targets)
            Target values.

        sample_weight : array-like of shape (n_samples,), default=None
            Individual weights for each sample
            raises error if sample_weight is passed and estimator
            fit method does not support it.

            .. versionadded:: 0.18

        **fit_params : dict
            Parameters routed to the `fit` method of the sub-estimator via the
            metadata routing API.

            .. versionadded:: 1.5

                Only available if
                `sklearn.set_config(enable_metadata_routing=True)` is set. See
                :ref:`Metadata Routing User Guide <metadata_routing>` for more
                details.

        Returns
        -------
        self : object
            Fitted `RANSACRegressor` estimator.

        Raises
        ------
        ValueError
            If no valid consensus set could be found. This occurs if
            `is_data_valid` and `is_model_valid` return False for all
            `max_trials` randomly chosen sub-samples.
        r2   ZcsrF)Úaccept_sparseÚensure_all_finite)Z	ensure_2d)Zvalidate_separatelyNzR`min_samples` needs to be explicitly set when estimator is not a LinearRegression.r!   r   zG`min_samples` may not be larger than number of samples: n_samples = %d.r7   c                 S   s   t  | | ¡S rF   )r(   r'   ©Zy_trueÚy_predr.   r.   r/   Ú<lambda>˜  ó    z%RANSACRegressor.fit.<locals>.<lambda>c                 S   s   t jt  | | ¡dd�S )Nr!   ©Zaxis)r(   Úsumr'   rM   r.   r.   r/   rO   š  s   ÿr8   c                 S   s   | | d S )Nr   r.   rM   r.   r.   r/   rO   Ÿ  rP   c                 S   s   t j| | d dd�S )Nr   r!   rQ   )r(   rR   rM   r.   r.   r/   rO   ¡  s   ÿ)r9   rJ   z[%s does not support sample_weight. Sample weights are only used for the calibration itself.)r2   r4   r3   )ÚparamsÚindiceszèRANSAC 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*).zÏRANSAC 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*).zšRANSAC found a valid consensus set but exited early due to skipping more iterations than `max_skips`. See estimator attributes for diagnostics (n_skips*).)7r   Údictr    r   r:   r
   r"   r,   Ú
isinstanceÚ
ValueErrorÚshaper(   r)   r;   Zmedianr'   rC   ÚndimÚcallabler   r9   Z
set_paramsr   ÚtypeÚ__name__r   r   r   r   r2   r#   Zn_skips_no_inliers_Zn_skips_invalid_data_Zn_skips_invalid_model_ZarangeZ	n_trials_r>   r?   r   r<   r   r=   r4   rR   r3   Úminr0   rB   r@   rA   ÚwarningsÚwarnr   Ú
estimator_Zinlier_mask_)&rG   ÚXÚyrJ   Z
fit_paramsZcheck_X_paramsZcheck_y_paramsr:   r,   r;   Zloss_functionr9   Zestimator_fit_has_sample_weightZestimator_nameZrouted_paramsZn_inliers_bestZ
score_bestZinlier_mask_bestZX_inlier_bestZy_inlier_bestZinlier_best_idxs_subsetr+   Zsample_idxsr>   Zsubset_idxsZX_subsetZy_subsetZfit_params_subsetrN   Zresiduals_subsetZinlier_mask_subsetZn_inliers_subsetZinlier_idxs_subsetZX_inlier_subsetZy_inlier_subsetZscore_params_inlier_subsetZscore_subsetZfit_params_best_idxs_subsetr.   r.   r/   r2   >  sT   4
ÿ




ÿ
ÿÿ






þÿ




ÿþüÿÿ
ÿÿ




ÿþý
ÿþ
ÿþüÿÿÿþüù
ÿzRANSACRegressor.fitc                 K   s^   t | ƒ t| |dddd�}t|| dƒ tƒ rFt| dfi |¤Žjd }ni }| jj|fi |¤ŽS )a   Predict 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.

        **params : dict
            Parameters routed to the `predict` method of the sub-estimator via
            the metadata routing API.

            .. versionadded:: 1.5

                Only available if
                `sklearn.set_config(enable_metadata_routing=True)` is set. See
                :ref:`Metadata Routing User Guide <metadata_routing>` for more
                details.

        Returns
        -------
        y : array, shape = [n_samples] or [n_samples, n_targets]
            Returns predicted values.
        FT©rL   rK   Úresetr4   )r   r    r   r   r   r:   r`   r4   )rG   ra   rS   Zpredict_paramsr.   r.   r/   r4   a  s    ûÿzRANSACRegressor.predictc                 K   s`   t | ƒ t| |dddd�}t|| dƒ tƒ rFt| dfi |¤Žjd }ni }| jj||fi |¤ŽS )a6  Return 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.

        **params : dict
            Parameters routed to the `score` method of the sub-estimator via
            the metadata routing API.

            .. versionadded:: 1.5

                Only available if
                `sklearn.set_config(enable_metadata_routing=True)` is set. See
                :ref:`Metadata Routing User Guide <metadata_routing>` for more
                details.

        Returns
        -------
        z : float
            Score of the prediction.
        FTrc   r3   )r   r    r   r   r   r:   r`   r3   )rG   ra   rb   rS   Zscore_paramsr.   r.   r/   r3   �  s    ûzRANSACRegressor.scorec                 C   sH   t | jjd�j| jtƒ jddd�jddd�jddd�jddd�d�}|S )aj  Get metadata routing of this object.

        Please check :ref:`User Guide <metadata_routing>` on how the routing
        mechanism works.

        .. versionadded:: 1.5

        Returns
        -------
        routing : MetadataRouter
            A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating
            routing information.
        )Úownerr2   )ZcallerZcalleer3   r4   )r:   Zmethod_mapping)r   Ú	__class__r\   Úaddr:   r   )rG   Zrouterr.   r.   r/   Úget_metadata_routing½  s    ÿþýüþz$RANSACRegressor.get_metadata_routingc                    s4   t ƒ  ¡ }| jd u rd|j_nt| jƒjj|j_|S )NT)ÚsuperÚ__sklearn_tags__r:   Z
input_tagsÚsparser   )rG   Útags©rf   r.   r/   rj   Õ  s
    


z RANSACRegressor.__sklearn_tags__)N)r\   Ú
__module__Ú__qualname__Ú__doc__r   r   r   r   r   rZ   r   r(   r#   r   rD   rU   Ú__annotations__rH   r	   r   r2   r4   r3   rh   rj   Ú__classcell__r.   r.   rm   r/   r1   R   sb   
 /ýþþþç þòþ  ..r1   )0r^   Únumbersr   r   Únumpyr(   Úbaser   r   r   r   r	   r
   Ú
exceptionsr   Úutilsr   r   r   Zutils._bunchr   Zutils._param_validationr   r   r   r   r   Zutils.metadata_routingr   r   r   r   r   Zutils.randomr   Zutils.validationr   r   r   r   r   r    Z_baser"   Úspacingr&   r0   r1   r.   r.   r.   r/   Ú<module>   s&     
"
ü