0PhfmdZddlZddlZddlmZmZddlmZddlZddl m Z ddl m Z mZm Z ddlmZddlmZdd lmZmZmZmZmZdd lmZmZdd lmZmZmZm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2dZ3d$dZ4ddddddZ5d%dZ6GddeeZ7GddeZ8GddZ9Gdd eee7Z: d&d"Z; d'd#Z`. Returns ------- dataset The ``Dataset`` abstraction intercept_decay The intercept decay )seedg?)rrandintnpiinfoint32maxdtypefloat32rrrrspissparsedataindptrindicesSPARSE_INTERCEPT_DECAYascontiguousarray) Xy sample_weight random_staterngr&CSRData ArrayDatadatasetintercept_decays Z/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/linear_model/_base.py make_datasetr?6s> \ * *C ;;q"(28,,0 1 1Dw"*" "  {1~~'!&!(AIq-dSSS0   # #)Aq-d;;; O ##T)copycopy_yr7 check_inputct|||\}}} |j\} } tj|} t |t jrd}|||}|r;t||ddgt|}t||j |d}nI| ||j |}|r*| r| }nt|dd | }|j } |rf| rt|d | \}}n5t|d || }| ||j d}||z}t|d || }||z}nd|| |j | }|jdkr|d| | }n#||jd| | }|| |j | }|||||fS)aCommon data preprocessing for fitting linear models. This helper is in charge of the following steps: - Ensure that `sample_weight` is an array or `None`. - If `check_input=True`, perform standard input validation of `X`, `y`. - Perform copies if requested to avoid side-effects in case of inplace modifications of the input. Then, if `fit_intercept=True` this preprocessing centers both `X` and `y` as follows: - if `X` is dense, center the data and store the mean vector in `X_offset`. - if `X` is sparse, store the mean in `X_offset` without centering `X`. The centering is expected to be handled by the linear solver where appropriate. - in either case, always center `y` and store the mean in `y_offset`. - both `X_offset` and `y_offset` are always weighted by `sample_weight` if not set to `None`. If `fit_intercept=False`, no centering is performed and `X_offset`, `y_offset` are set to zero. Returns ------- X_out : {ndarray, sparse matrix} of shape (n_samples, n_features) If copy=True a copy of the input X is triggered, otherwise operations are inplace. If input X is dense, then X_out is centered. y_out : {ndarray, sparse matrix} of shape (n_samples,) or (n_samples, n_targets) Centered version of y. Possibly performed inplace on input y depending on the copy_y parameter. X_offset : ndarray of shape (n_features,) The mean per column of input X. y_offset : float or ndarray of shape (n_features,) X_scale : ndarray of shape (n_features,) Always an array of ones. TODO: refactor the code base to make it possible to remove this unused variable. Ncsrcsc)rA accept_sparser,F)r,rA ensure_2drAKT)orderrAxpr)axisweights)rMrNrL)r,devicer%)rshaper.r/ isinstancenumbersNumberasarrayrrr,astyperArr rzerosndimones)r5r6 fit_interceptrArBr7rCrL_device_ n_samples n_features X_is_sparsedtype_X_offsetX_vary_offsetX_scales r>_preprocess_datareksb.aMBBNB7GIz+a..K-00   =11  H  D>TUW>X>X    v G G G IIavI . .  H HFFHH'4BGGG WFJ  0MRRROHee=RHHHHyy17y??H MAAA}DDD X 88Jagg8FF 6Q;;zz#VGzDDHHxx &xIIHggjg@@G a8W ,,r@FcXt|||\}}|jd}||}tj|stj|rt j|df||f}tj|rt||}n!|r||dddfz}n||dddfz}tj|rt||}nC|r!|jdkr||z}n0||dddfz}n |jdkr||z}n||dddfz}|||fS)aRescale data sample-wise by square root of sample_weight. For many linear models, this enables easy support for sample_weight because (y - X w)' S (y - X w) with S = diag(sample_weight) becomes ||y_rescaled - X_rescaled w||_2^2 when setting y_rescaled = sqrt(S) y X_rescaled = sqrt(S) X Returns ------- X_rescaled : {array-like, sparse matrix} y_rescaled : {array-like, sparse matrix} r)rQNr%) rrQsqrtr.r/r dia_matrixrrX) r5r6r7inplacerLr[r]sample_weight_sqrt sw_matrixs r> _rescale_datarlsq0 !Q . .EB I// {1~~ Q %  #Iy+A    {1~~0 Iq ) )  0 #AAAtG, ,AA&qqq$w//A {1~~ 4 Iq ) )  4v{{'''400v{{***111d733 a# ##r@c:eZdZdZedZdZdZdZdS) LinearModelzBase class for Linear ModelscdS)z Fit model.N)selfr5r6s r>fitzLinearModel.fit sr@ct|t||gdd}|j}|jdkr ||z|jzS||jz|jzS)NrErFcooFrGresetr%)r"r#coef_rX intercept_T)rqr5rxs r>_decision_functionzLinearModel._decision_functionsc $1F1F1Fe T T T  :??u9t. .uw;0 0r@c,||S)a! Predict using the linear model. Parameters ---------- X : array-like or sparse matrix, shape (n_samples, n_features) Samples. Returns ------- C : array, shape (n_samples,) Returns predicted values. )r{)rqr5s r>predictzLinearModel.predicts&&q)))r@ct|||\}}|jri||j|jd}|||x}|_|jdkr |||zz }n |||jzz }||_dSd|_dS)zSet the intercept_FrIr%rPN) rrZrVrxr,dividerXrzry)rqrarcrdrLr[rxrys r>_set_interceptzLinearModel._set_intercept+sh'::A   "IIdj'-eIDDE!#5'!:!: :EDJzQ%5(88 %57(:: (DOOO"DOOOr@N) __name__ __module__ __qualname____doc__rrrr{r}rrpr@r>rnrn s`&&^111*** """""r@rn) metaclassc$eZdZdZdZdZdZdS)LinearClassifierMixinzRMixin for linear classifiers. Handles prediction for sparse and dense X. ct|t|\}}t||dd}t||jjd|jz}|jdkr'|jddkr| |dn|S)a Predict confidence scores for samples. The confidence score for a sample is proportional to the signed distance of that sample to the hyperplane. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The data matrix for which we want to get the confidence scores. Returns ------- scores : ndarray of shape (n_samples,) or (n_samples, n_classes) Confidence scores per `(n_samples, n_classes)` combination. In the binary case, confidence score for `self.classes_[1]` where >0 means this class would be predicted. rEFrvT) dense_outputr%)) r"rr#rrxrzryrXrQreshape)rqr5rLr[scoress r>decision_functionz'LinearClassifierMixin.decision_functionIs& a  A $e D D D DJLtDDDtV aFLOq$8$8 JJvu % % % r@c8t|\}}||}t|jdkr(||dkt |}n||d}||j|dS)a~ Predict class labels for samples in X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The data matrix for which we want to get the predictions. Returns ------- y_pred : ndarray of shape (n_samples,) Vector containing the class labels for each sample. r%rrM) rrlenrQrVrargmaxtakeclasses_)rqr5rLr[rr2s r>r}zLinearClassifierMixin.predictgsa  A''** v|   ! !ii N2,>,>??GGiiQi//Gwwt}gAw666r@c||}t|||jdkrtjd|z |gjS||d|jddfz}|S)zProbability estimation for OvR logistic regression. Positive class probabilities are computed as 1. / (1. + np.exp(-self.decision_function(X))); multiclass is handled by normalizing that over all classes. outr%rrr) rr rXr(vstackrzsumrrQ)rqr5probs r>_predict_proba_lrz'LinearClassifierMixin._predict_proba_lr~s%%a(( d 9>>9a$h-..0 0 DHH!H$$,,djmR-@AA ADKr@N)rrrrrr}rrpr@r>rrCsK    <777.r@rceZdZdZdZdZdS)SparseCoefMixinzlMixin for converting coef_ to and from CSR format. L1-regularizing estimators should inherit this. cd}t||tj|jr|j|_|S)a Convert coefficient matrix to dense array format. Converts the ``coef_`` member (back) to a numpy.ndarray. This is the default format of ``coef_`` and is required for fitting, so calling this method is only required on models that have previously been sparsified; otherwise, it is a no-op. Returns ------- self Fitted estimator. z6Estimator, %(name)s, must be fitted before densifying.msg)r"r.r/rxtoarrayrqrs r>densifyzSparseCoefMixin.densifysKG#&&&& ;tz " " .++--DJ r@chd}t||tj|j|_|S)a Convert coefficient matrix to sparse format. Converts the ``coef_`` member to a scipy.sparse matrix, which for L1-regularized models can be much more memory- and storage-efficient than the usual numpy.ndarray representation. The ``intercept_`` member is not converted. Returns ------- self Fitted estimator. Notes ----- For non-sparse models, i.e. when there are not many zeros in ``coef_``, this may actually *increase* memory usage, so use this method with care. A rule of thumb is that the number of zero elements, which can be computed with ``(coef_ == 0).sum()``, must be more than 50% for this to provide significant benefits. After calling this method, further fitting with the partial_fit method (if any) will not work until you call densify. z7Estimator, %(name)s, must be fitted before sparsifying.r)r"r. csr_matrixrxrs r>sparsifyzSparseCoefMixin.sparsifys54H#&&&&]4:..  r@N)rrrrrrrpr@r>rrs< (r@rceZdZUdZdgdgdegdgdZeed<ddddddZe d d d Z fd Z xZ S) LinearRegressionaj Ordinary least squares Linear Regression. LinearRegression fits a linear model with coefficients w = (w1, ..., wp) to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation. Parameters ---------- fit_intercept : bool, default=True Whether to calculate the intercept for this model. If set to False, no intercept will be used in calculations (i.e. data is expected to be centered). copy_X : bool, default=True If True, X will be copied; else, it may be overwritten. n_jobs : int, default=None The number of jobs to use for the computation. This will only provide speedup in case of sufficiently large problems, that is if firstly `n_targets > 1` and secondly `X` is sparse or if `positive` is set to `True`. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. positive : bool, default=False When set to ``True``, forces the coefficients to be positive. This option is only supported for dense arrays. .. versionadded:: 0.24 Attributes ---------- coef_ : array of shape (n_features, ) or (n_targets, n_features) Estimated coefficients for the linear regression problem. If multiple targets are passed during the fit (y 2D), this is a 2D array of shape (n_targets, n_features), while if only one target is passed, this is a 1D array of length n_features. rank_ : int Rank of matrix `X`. Only available when `X` is dense. singular_ : array of shape (min(X, y),) Singular values of `X`. Only available when `X` is dense. intercept_ : float or array of shape (n_targets,) Independent term in the linear model. Set to 0.0 if `fit_intercept = False`. 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 -------- Ridge : Ridge regression addresses some of the problems of Ordinary Least Squares by imposing a penalty on the size of the coefficients with l2 regularization. Lasso : The Lasso is a linear model that estimates sparse coefficients with l1 regularization. ElasticNet : Elastic-Net is a linear regression model trained with both l1 and l2 -norm regularization of the coefficients. Notes ----- From the implementation point of view, this is just plain Ordinary Least Squares (scipy.linalg.lstsq) or Non Negative Least Squares (scipy.optimize.nnls) wrapped as a predictor object. Examples -------- >>> import numpy as np >>> from sklearn.linear_model import LinearRegression >>> X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]]) >>> # y = 1 * x_0 + 2 * x_1 + 3 >>> y = np.dot(X, np.array([1, 2])) + 3 >>> reg = LinearRegression().fit(X, y) >>> reg.score(X, y) 1.0 >>> reg.coef_ array([1., 2.]) >>> reg.intercept_ np.float64(3.0...) >>> reg.predict(np.array([[3, 5]])) array([16.]) booleanNrZcopy_Xn_jobspositive_parameter_constraintsTFc>||_||_||_||_dSNr)rqrZrrrs r>__init__zLinearRegression.__init__0s%+    r@)prefer_skip_nested_validationc |j}|jrdngd}t||ddd\|du}|rt|jd}|jot j }t|j ||\}} } |rt||\|jrj d kr"tj d |_nt| fd t!jd D} t%jd| D|_nUt jr|| z |rfd} fd} n fd} fd} t(jj| | j d krt/d |_nt| fdt!jd D} t%jd| D|_not1jt%jjjz}t+j|\|_}|_|_|jj|_j d krt%j|j|_| || | |S)ap Fit linear model. 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. Will be cast to X's dtype if necessary. sample_weight : array-like of shape (n_samples,), default=None Individual weights for each sample. .. versionadded:: 0.17 parameter *sample_weight* support to LinearRegression. Returns ------- self : object Fitted Estimator. FrtT)rG y_numeric multi_outputforce_writeableN)r,ensure_non_negative)rZrAr7)rir r)rc3rK|]1}ttjdd|fV2dSr)rrnnls).0jr5r6s r> z'LinearRegression.fit..sW00;<*GHM**1a1g66000000r@r%cg|] }|d Srrprrs r> z(LinearRegression.fit..'?'?'?3A'?'?'?r@c`||zz Srdotbr5X_offset_scalerjs r>matvecz$LinearRegression.fit..matvecs*5588&8155;P;P&PPPr@cjj||zz Sr)rzrrs r>rmatvecz%LinearRegression.fit..rmatvecs,3771::?Q9R9R(RRRr@cZ||z Srrrr5rs r>rz$LinearRegression.fit..matvecs$5588aeeN&;&;;;r@chj||zz Sr)rzrrrs r>rz%LinearRegression.fit..rmatvecs'3771::(@@@r@)rQrrc3K|]>}ttdd|fV?dSr)rr ravel)rr X_centeredr6s r>rz'LinearRegression.fit..s]00"GDMM*a1gmmoo>>000000r@cg|] }|d Srrprs r>rz(LinearRegression.fit..rr@)cond)!rrr#r!r,rr.r/rerZrlrXrrrxrrangerQr(rrrLinearOperatorr r+finfoepslstsqrank_ singular_rzrr)rqr5r6r7n_jobs_rGhas_swcopy_X_in_preprocess_datararcrdoutsrrrr[rrrjs `` @@@r>rrzLinearRegression.fit=s0+!%I4I4I4I   '    1d*  0qTM%)K$F A4F!,< ,*' - - - )1h'  (51m-F((( $Aq$ =- &vzz%]1a003 0xw///00000@Eagaj@Q@Q000 Y'?'?$'?'?'?@@ [^^$ &%/N AQQQQQQQSSSSSSSS <<<<<<AAAAAA 55gfg6Jvzz!*a003 0xw///00000"171:..000 Y'?'?$'?'?'?@@ qw<<"(17"3"3"77D8> QPT8U8U8U 5DJ4:t~DJ 6Q;;$*--DJ Hh888 r@clt}|j |j_|Sr)super__sklearn_tags__r input_tagsr)rqtags __class__s r>rz!LinearRegression.__sklearn_tags__s,ww''))%)]!2 r@r) rrrrrrdict__annotations__rrrrr __classcell__)rs@r>rrs]]@$+"K $$D ! ! ! ! !\555rrr65rhr@rh㈵>c |jd}|dz}t|dz|dz }|dd|f||z ||z} |dd|f||z ||z} tj| | } |||f} |j| jg} |d| D}t |}tj| | ||std|d|d| d | d dS) a^Computes a single element of the gram matrix and compares it to the corresponding element of the user supplied gram matrix. If the values do not match a ValueError will be thrown. Parameters ---------- X : ndarray of shape (n_samples, n_features) Data array. precompute : array-like of shape (n_features, n_features) User-supplied gram matrix. X_offset : ndarray of shape (n_features,) Array of feature means used to center design matrix. X_scale : ndarray of shape (n_features,) Array of feature scale factors used to normalize design matrix. rtol : float, default=None Relative tolerance; see numpy.allclose If None, it is set to 1e-4 for arrays of dtype numpy.float32 and 1e-7 otherwise. atol : float, default=1e-5 absolute tolerance; see :func`numpy.allclose`. Note that the default here is more tolerant than the default for :func:`numpy.testing.assert_allclose`, where `atol=0`. Raises ------ ValueError Raised when the provided Gram matrix is not consistent. r%r Nc6g|]}|tjkrdndS)g-C6?gHz>)r(r-)rr,s r>rz2_check_precomputed_gram_matrix..s(KKK5"*,,$KKKr@)rtolatolzGram matrix passed in via 'precompute' parameter did not pass validation when a single element was checked - please check that it was computed properly. For element (,z) we computed z! but the user-supplied value was .)rQminr(rr,r+isclose ValueError)r5 precomputerardrrr^f1f2v1v2expectedactualdtypesrtolss r>_check_precomputed_gram_matrixrsBLJ qB R!VZ!^ $ $B AAArE(Xb\ !WR[ 0B AAArE(Xb\ !WR[ 0Bvb"~~H B F /F |KKFKKK5zz :hT = = =  ')  ,.               r@c|j\}} tj|rd}t|||d||\}}} } } n3t||||||\}}} } } |t |||\}}} t |dr\|rFt j| t j| stj dtd}d}n|rt||| | t|tr |dkr|| k}|dur:t j| | f|jd }t j|j|| t |dsd}t |dr|t j|j|j}|jd kr4t j| |d }t j|j|| nG|jd }t j| |f|d }t j|j||j ||| | | ||fS)zFunction used at beginning of fit in linear models with L1 or L0 penalty. This function applies _preprocess_data and additionally computes the gram matrix `precompute` as needed as well as `Xy`. F)rZrArCr7N)r7 __array__zVGram matrix was provided but X was centered to fit intercept: recomputing Gram matrix.autoTC)rQr,rKrr%F)rQrr/rerlhasattrr(allcloserWwarningswarn UserWarningrrRstremptyr,rrz result_typerX)r5r6XyrrZrArCr7r]r^rarcrdr[ common_dtype n_targetss r>_pre_fitr swGIz qG ,< '#' - - - )1h''-= '#' - - - )1h'  $#Aq FFFGAq!z;''M  MXrx 7K7K!L!L M M:     JBB  M +1j(G L L L*c"",zV';';+ TXZ$rs`''''''''**********$$$$$$43333333 ,+++++........222222SSSSSSSSSS  2$2$2$2$t  ^-^-^-^-^-L6$6$6$6$r4"4"4"4"4"-74"4"4"4"rIIIIIOIIIX77777777tlllll'lll`7;= = = = NZ=Z=Z=Z=Z=Z=r@