0Ph0ddlmZmZddlZddlmZddlmZm Z m Z ddl m Z ddl mZddlmZdd lmZdd lmZmZd d lmZdd ZGddee eZdS))IntegralRealN)optimize) BaseEstimatorRegressorMixin _fit_context)axis0_safe_slice)Interval)safe_sparse_dot)_check_optimize_result)_check_sample_weight validate_data) LinearModelcP|j\}}|dz|jdk}|r|d} |d} |d|}tj|} |t||z } |r| | z} tj| } | || zk}| |}tj|}|jd|z }||}tj|}d|ztj||zz| |z|dzzz }| |}|||z}tj|j|}|| z }|rtj|dz}ntj|dz}t||| }d| z t||z|d|<tj |}| |dk}d||<t|||}|||z}|d|xxd|zt||zzcc<|d|xx|dz|zz cc<| |d<|dxx||dzzzcc<|dxx|| z zcc<|rEd tj|z| z |d<|dxxd|ztj|zzcc<| | z|z|z}||tj||zz }||fS) aReturns the Huber loss and the gradient. Parameters ---------- w : ndarray, shape (n_features + 1,) or (n_features + 2,) Feature vector. w[:n_features] gives the coefficients w[-1] gives the scale factor and if the intercept is fit w[-2] gives the intercept factor. X : ndarray of shape (n_samples, n_features) Input data. y : ndarray of shape (n_samples,) Target vector. epsilon : float Robustness of the Huber estimator. alpha : float Regularization parameter. sample_weight : ndarray of shape (n_samples,), default=None Weight assigned to each sample. Returns ------- loss : float Huber loss. gradient : ndarray, shape (len(w)) Returns the derivative of the Huber loss with respect to each coefficient, intercept and the scale as a vector. rrNg@rgg) shapenpsumr abs count_nonzerodotTzerosr ones_like) wXyepsilonalpha sample_weight_ n_features fit_intercept interceptsigma n_samples linear_lossabs_linear_loss outliers_maskoutliers num_outliersn_non_outliers outliers_sw n_sw_outliers outlier_loss non_outliersweighted_non_outliers weighted_loss squared_lossgradX_non_outlierssigned_outlierssigned_outliers_mask X_outliers sw_outlierslosss [/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/linear_model/_huber.py_huber_loss_and_gradientr?s>FGMAzNagaj0MbE bEE +:+A}%%Ioa+++K!y f[))O#go5M}-H#M22LWQZ,.N .KF;''M g {X5666 - '1* , - ~.L)=.9LHF02LAAM 5(L(x Q''x Q'''q=..IIIN e o&;^LLL * l8,,O&}59,0O()!!]LAAJ .@K*w/+z*R*RSS *q(DHHHH  **HHHHHH u$$HHH8"&!6777%?R RC'MBF;$7$777 u | +l :DEBF1aLL  D :c eZdZUdZeedddgeedddgeedddgdgdgeedddgd Zee d <d d d dddd dZ e dddZ fdZ xZS)HuberRegressoraL2-regularized linear regression model that is robust to outliers. The Huber Regressor optimizes the squared loss for the samples where ``|(y - Xw - c) / sigma| < epsilon`` and the absolute loss for the samples where ``|(y - Xw - c) / sigma| > epsilon``, where the model coefficients ``w``, the intercept ``c`` and the scale ``sigma`` are parameters to be optimized. The parameter `sigma` makes sure that if `y` is scaled up or down by a certain factor, one does not need to rescale `epsilon` to achieve the same robustness. Note that this does not take into account the fact that the different features of `X` may be of different scales. The Huber loss function has the advantage of not being heavily influenced by the outliers while not completely ignoring their effect. Read more in the :ref:`User Guide ` .. versionadded:: 0.18 Parameters ---------- epsilon : float, default=1.35 The parameter epsilon controls the number of samples that should be classified as outliers. The smaller the epsilon, the more robust it is to outliers. Epsilon must be in the range `[1, inf)`. max_iter : int, default=100 Maximum number of iterations that ``scipy.optimize.minimize(method="L-BFGS-B")`` should run for. alpha : float, default=0.0001 Strength of the squared L2 regularization. Note that the penalty is equal to ``alpha * ||w||^2``. Must be in the range `[0, inf)`. warm_start : bool, default=False This is useful if the stored attributes of a previously used model has to be reused. If set to False, then the coefficients will be rewritten for every call to fit. See :term:`the Glossary `. fit_intercept : bool, default=True Whether or not to fit the intercept. This can be set to False if the data is already centered around the origin. tol : float, default=1e-05 The iteration will stop when ``max{|proj g_i | i = 1, ..., n}`` <= ``tol`` where pg_i is the i-th component of the projected gradient. Attributes ---------- coef_ : array, shape (n_features,) Features got by optimizing the L2-regularized Huber loss. intercept_ : float Bias. scale_ : float The value by which ``|y - Xw - c|`` is scaled down. 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 n_iter_ : int Number of iterations that ``scipy.optimize.minimize(method="L-BFGS-B")`` has run for. .. versionchanged:: 0.20 In SciPy <= 1.0.0 the number of lbfgs iterations may exceed ``max_iter``. ``n_iter_`` will now report at most ``max_iter``. outliers_ : array, shape (n_samples,) A boolean mask which is set to True where the samples are identified as outliers. See Also -------- RANSACRegressor : RANSAC (RANdom SAmple Consensus) algorithm. TheilSenRegressor : Theil-Sen Estimator robust multivariate regression model. SGDRegressor : Fitted by minimizing a regularized empirical loss with SGD. References ---------- .. [1] Peter J. Huber, Elvezio M. Ronchetti, Robust Statistics Concomitant scale estimates, p. 172 .. [2] Art B. Owen (2006), `A robust hybrid of lasso and ridge regression. `_ Examples -------- >>> import numpy as np >>> from sklearn.linear_model import HuberRegressor, LinearRegression >>> from sklearn.datasets import make_regression >>> rng = np.random.RandomState(0) >>> X, y, coef = make_regression( ... n_samples=200, n_features=2, noise=4.0, coef=True, random_state=0) >>> X[:4] = rng.uniform(10, 20, (4, 2)) >>> y[:4] = rng.uniform(10, 20, 4) >>> huber = HuberRegressor().fit(X, y) >>> huber.score(X, y) -7.284... >>> huber.predict(X[:1,]) array([806.7200...]) >>> linear = LinearRegression().fit(X, y) >>> print("True coefficients:", coef) True coefficients: [20.4923... 34.1698...] >>> print("Huber coefficients:", huber.coef_) Huber coefficients: [17.7906... 31.0106...] >>> print("Linear Regression coefficients:", linear.coef_) Linear Regression coefficients: [-1.9221... 7.0226...] g?Nleft)closedrbooleanr!max_iterr" warm_startr&tol_parameter_constraintsg?dg-C6?FTgh㈵>cZ||_||_||_||_||_||_dSNrG)selfr!rHr"rIr&rJs r>__init__zHuberRegressor.__init__s3    $*r@)prefer_skip_nested_validationc t|||ddgdtjtjg\}}t ||}|jr8t |dr(tj|j|j |j gf}nQ|j r#tj |j ddz}n"tj |j ddz}d|d<tjtj tjg|j d df}tjtjjd z|dd <t%jt(|d d|||j|j|f|j|jdd | }|j}|jdkrt7d|jzt;d||j|_|d|_ |j r|d|_ nd|_ |d|j d|_tj|tA||jz |j z }||j |jzk|_!|S)a5Fit the model according to the given training data. Parameters ---------- X : array-like, shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like, shape (n_samples,) Target vector relative to X. sample_weight : array-like, shape (n_samples,) Weight given to each sample. Returns ------- self : object Fitted `HuberRegressor` estimator. FcsrT)copy accept_sparse y_numericdtypecoef_rrrr zL-BFGS-B)maxitergtoliprint)methodjacargsoptionsboundszEHuberRegressor convergence failed: l-BFGS-b solver terminated with %slbfgsrrFN)"rrfloat64float32rrIhasattr concatenaterX intercept_scale_r&rrtileinffinfoepsrminimizer?r!r"rHrJxstatus ValueErrormessager n_iter_rr outliers_)rOrr r# parametersraopt_resresiduals r>fitzHuberRegressor.fits5*   ':rz*   1-]A>> ? wtW55 dot{5S(TUUJJ! 6Xagaj1n55 Xagaj1n55 JrN 26'26*Z-=a-@!,DEE,,025r 1 # $ Q dj-@ $ tx2NN   Y >Q  W/" .gw NN  n   "(nDOO!DO !'!* - 6!oa<<> r@c`t}d|j_|S)NT)super__sklearn_tags__ input_tagssparse)rOtags __class__s r>rzzHuberRegressor.__sklearn_tags__cs'ww''))!% r@rN)__name__ __module__ __qualname____doc__r rrrKdict__annotations__rPr rwrz __classcell__)r~s@r>rBrBs5wwtHT3V<<<=Xh4???@(4D8889 k#sD8889 $$D "\555LLL65L\r@rBrN)numbersrrnumpyrscipyrbaserrr utils._maskr utils._param_validationr utils.extmathr utils.optimizer utils.validationrr_baserr?rBr@r>rs(#""""""">>>>>>>>>>******......++++++333333BBBBBBBBkkkk\fffff[.-fffffr@