MpjafSrSSKrSSKJr SSKJrJrJr SSK J r SSK J r J r Sr"SS 5rg) zA Loss functions for linear models with raw_prediction = X @ coef N)sparse) get_namespaceget_namespace_and_devicemove_to)_align_api_if_sparse)safe_sparse_dot squared_normc URSn[R"U5(a7[[ UR [R "US4X"4S9U-SS95$USS2S4U-nUR U-$)z/Compute the sandwich product X.T @ diag(W) @ X.rshapeT) dense_outputN)r rissparserrT dia_array)XW n_samplesWXs ]/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/sklearn/linear_model/_linear_loss.py sandwich_dotrs{ I q#   !Q /EFJ!   q$wZ!^ssRxc\rSrSrSrSrSSjrSrSrSr SS jr SS jr SS jr SS jr SS jrSrg)LinearModelLoss/azGeneral class for loss functions with raw_prediction = X @ coef + intercept. Note that raw_prediction is also known as linear predictor. The loss is the average of per sample losses and includes a term for L2 regularization:: loss = 1 / s_sum * sum_i s_i loss(y_i, X_i @ coef + intercept) + 1/2 * l2_reg_strength * ||coef||_2^2 with sample weights s_i=1 if sample_weight=None and s_sum=sum_i s_i. Gradient and hessian, for simplicity without intercept, are:: gradient = 1 / s_sum * X.T @ loss.gradient + l2_reg_strength * coef hessian = 1 / s_sum * X.T @ diag(loss.hessian) @ X + l2_reg_strength * identity Conventions: if fit_intercept: n_dof = n_features + 1 else: n_dof = n_features if base_loss.is_multiclass: coef.shape = (n_classes, n_dof) or ravelled (n_classes * n_dof,) else: coef.shape = (n_dof,) The intercept term is at the end of the coef array: if base_loss.is_multiclass: if coef.shape (n_classes, n_dof): intercept = coef[:, -1] if coef.shape (n_classes * n_dof,) intercept = coef[n_classes * n_features:] = coef[(n_dof-1):] intercept.shape = (n_classes,) else: intercept = coef[-1] Shape of gradient follows shape of coef. gradient.shape = coef.shape But hessian (to make our lives simpler) are always 2-d: if base_loss.is_multiclass: hessian.shape = (n_classes * n_dof, n_classes * n_dof) else: hessian.shape = (n_dof, n_dof) Note: if coef has shape (n_classes * n_dof,), the classes are expected to be contiguous, i.e. the 2d-array can be reconstructed as coef.reshape((n_classes, -1), order="F") The option order="F" makes coef[:, i] contiguous. This, in turn, makes the coefficients without intercept, coef[:, :-1], contiguous and speeds up matrix-vector computations. Note: If the average loss per sample is wanted instead of the sum of the loss per sample, one can simply use a rescaled sample_weight such that sum(sample_weight) = 1. Parameters ---------- base_loss : instance of class BaseLoss from sklearn._loss. fit_intercept : bool cXlX lgN base_loss fit_intercept)selfrrs r__init__LinearModelLoss.__init__ss "*rNcURSnURRnUR(aUS-nOUnURR(a[ R "XE4USS9nU$[ R "XRS9nU$)aAllocate coef of correct shape with zeros. Parameters: ----------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. dtype : data-type, default=None Overrides the data type of coef. With dtype=None, coef will have the same dtype as X. Returns ------- coef : ndarray of shape (n_dof,) or (n_classes, n_dof) Coefficients of a linear model. F)r dtypeorder)r r&)r r n_classesr is_multiclassnpzeros)r rr& n_featuresr(n_dofcoefs rinit_zero_coefLinearModelLoss.init_zero_coefwsu WWQZ NN,,   NEE >> ' '889"4EMD 88%5D rcPURR(d&UR(a USnUSSnX24$SnUnX24$URS:Xa'UR URR S4SS9nOUnUR(aUSS2S4nUSS2SS24nX24$SnX24$)a(Helper function to get coefficients and intercept. Parameters ---------- coef : ndarray of shape (n_dof,), (n_classes, n_dof) or (n_classes * n_dof,) Coefficients of a linear model. If shape (n_classes * n_dof,), the classes of one feature are contiguous, i.e. one reconstructs the 2d-array via coef.reshape((n_classes, -1), order="F"). Returns ------- weights : ndarray of shape (n_features,) or (n_classes, n_features) Coefficients without intercept term. intercept : float or ndarray of shape (n_classes,) Intercept terms. Nr$r%r')rr)rndimreshaper()r r. interceptweightss rweight_intercept LinearModelLoss.weight_intercepts$~~++!! H s) !! !!yyA~,,(@(@"'ES,Q!!#ArEN !!SbS&/!! !!rcURU5up4[U5upVnURX2RUS9nURXBRUS9n URR (dX(-U -n OX(R -U -n X4U 4$)aHelper function to get coefficients, intercept and raw_prediction. Parameters ---------- coef : ndarray of shape (n_dof,), (n_classes, n_dof) or (n_classes * n_dof,) Coefficients of a linear model. If shape (n_classes * n_dof,), the classes of one feature are contiguous, i.e. one reconstructs the 2d-array via coef.reshape((n_classes, -1), order="F"). X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. Returns ------- weights : ndarray of shape (n_features,) or (n_classes, n_features) Coefficients without intercept term. intercept : float or ndarray of shape (n_classes,) Intercept terms. raw_prediction : ndarray of shape (n_samples,) or (n_samples, n_classes) )r&device)r9rasarrayr&rr)r) r r.rr8r7xp_device_ weights_xp intercept_xpraw_predictions rweight_intercept_raw$LinearModelLoss.weight_intercept_raws,"22481!4wZZwwwZG zz)777zK ~~++^l:N- 11rcbURS:XaX-O [U5n[SU-U-5$)z5Compute L2 penalty term l2_reg_strength/2 *||w||_2^2.r$g?)r5r float)r r8l2_reg_strengthnorm2_ws r l2_penaltyLinearModelLoss.l2_penaltys1'.||q'8'#l7>SS?*W455rcfURSnUcURX5upnOURU5upURR UUUUS9n [ X#U5upUcUOU R U5n[U R U 5U- 5n US:aXRX5- n U $)aGCompute the loss as weighted average over point-wise losses. Parameters ---------- coef : ndarray of shape (n_dof,), (n_classes, n_dof) or (n_classes * n_dof,) Coefficients of a linear model. If shape (n_classes * n_dof,), the classes of one feature are contiguous, i.e. one reconstructs the 2d-array via coef.reshape((n_classes, -1), order="F"). X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. y : contiguous array of shape (n_samples,) Observed, true target values. sample_weight : None or contiguous array of shape (n_samples,), default=None Sample weights. l2_reg_strength : float, default=0.0 L2 regularization strength n_threads : int, default=1 Number of OpenMP threads to use. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). If provided, these are used. If None, then raw_prediction = X @ coef + intercept is calculated. Returns ------- loss : float Weighted average of losses per sample, plus penalty. ry_truerC sample_weight n_threads) r rDr9rlossrsumrGrJ)r r.ryrOrHrPrCrr8r7rQr>r?sw_sums rrQLinearModelLoss.losssNGGAJ  !151J1J41S .G!%!6!6t!< G~~"")' #  aM2+3 9NRVVD\F*+ Q  OOG= =D rcURURRsupn U [UR5-n UcUR X5upnOUR U5upURRUUUUS9up[X#U5unnUcUOURU5n[URU5U- 5nXRX5- nUU-nURR(dm[R"XRS9nUR U-n[#U[SS9X\--USU &UR(aURU5US'UU4$[R$"X4U RSS9nUR U-n[#U[SS9X\--USS2SU 24'UR(a$[#URUS S 9[SS9USS2S4'UR&S :XaUR)SS 9nUU4$) aComputes the sum of loss and gradient w.r.t. coef. Parameters ---------- coef : ndarray of shape (n_dof,), (n_classes, n_dof) or (n_classes * n_dof,) Coefficients of a linear model. If shape (n_classes * n_dof,), the classes of one feature are contiguous, i.e. one reconstructs the 2d-array via coef.reshape((n_classes, -1), order="F"). X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. y : contiguous array of shape (n_samples,) Observed, true target values. sample_weight : None or contiguous array of shape (n_samples,), default=None Sample weights. l2_reg_strength : float, default=0.0 L2 regularization strength n_threads : int, default=1 Number of OpenMP threads to use. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). If provided, these are used. If None, then raw_prediction = X @ coef + intercept is calculated. Returns ------- loss : float Weighted average of losses per sample, plus penalty. gradient : ndarray of shape coef.shape The gradient of the loss. NrMr&cpu)r>r<r2r%r&r'raxisr$r4)r rr(intrrDr9 loss_gradientrrRrGrJr)r* empty_liker&rremptyr5ravel)r r.rrSrOrHrPrCrr,r(r-r8r7rQgrad_pointwiser>r?rTgradX_gradgrad_Xs rr]LinearModelLoss.loss_gradient#sT./WWdnn6N6N*S!3!344  !151J1J41S .G!%!6!6t!< G#~~;;)' <  aM2A+3 9NRVVD\F*+ 99& ~~++==]];DSS>)F2e47PP * !!66.1R$Tz88Y.gmm3OD#%%)F2e47PP KZK !!%FF>F2r%QU yyA~zzz,Tzrc@URURRsupn U [UR5-n UcUR X5upnOUR U5upURRUUUUS9nUcUO[R"U5nX-nURR(d[[R"XRS9nURU-X\--USU &UR(aUR5US'U$[R"X4U RSS9nURU-X\--USS2SU 24'UR(aURSS9USS2S4'URS :XaUR!SS 9$U$) a-Computes the gradient w.r.t. coef. Parameters ---------- coef : ndarray of shape (n_dof,), (n_classes, n_dof) or (n_classes * n_dof,) Coefficients of a linear model. If shape (n_classes * n_dof,), the classes of one feature are contiguous, i.e. one reconstructs the 2d-array via coef.reshape((n_classes, -1), order="F"). X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. y : contiguous array of shape (n_samples,) Observed, true target values. sample_weight : None or contiguous array of shape (n_samples,), default=None Sample weights. l2_reg_strength : float, default=0.0 L2 regularization strength n_threads : int, default=1 Number of OpenMP threads to use. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). If provided, these are used. If None, then raw_prediction = X @ coef + intercept is calculated. Returns ------- gradient : ndarray of shape coef.shape The gradient of the loss. NrMrWr2r%rYrrZr$r4)r rr(r\rrDr9gradientr*rRr)r^r&rr_r5r`)r r.rrSrOrHrPrCrr,r(r-r8r7rarTrbs rrgLinearModelLoss.gradient}sN./WWdnn6N6N*S!3!344  !151J1J41S .G!%!6!6t!< G00)' 1  ,3 9N ~~++==]];D !n 47P PD* !!)--/RK88Y.gmm3OD#1#3#3a#7/:S#SDKZK !!,00a08QU yyA~zzz,, rc f URURRsupn U [UR5-n U cUR X5upn OUR U5upUcU O[R"U5nUc [R"XRSS9nOURUR:wa&[SURSURS35eURR(a&URR(d [S5eUnURnUc"[R "UU4URS9nOURUU4:wa[S UU4S UR<S35eURR(aAURR"(d&URR(d [S 5eUnURR(GdEURR%UU UUS 9unnUU-nUU-n[R&"US :*US9S:n[R("U5nUR*U-X^--USU &UR(aUR5US'U(aUUU4$[-UU5USU 2SU 24'US :aBURR"(aSOSnUR/SUS9SX-U S-2==U- ss'UR(a4UR*U-nUUSS2S4'UUSSS24'UR5US'GOcURR1UU UUS 9unnUU-nUR/X4SS9nUR*U-X^--USS2SU 24'UR(aURS S9USS2S4'UR2S:XaUR5SS9nUbUU- nOSU- n[7U 5GHZnUSS2U4SUSS2U4- -U-n[-UU5UUX-U 2UX-U 24'UR(aPUR*U-nUUUX-U 2X-U-4'UUX-U-UX-U 24'UR5UX-U-X-U-4'[7US-U 5HnUSS2U4*USS2U4-U-n[-UU5UUX-U 2UX-U 24'UR(aPUR*U-nUUUX-U 2X-U-4'UUX-U-UX-U 24'UR5UX-U-X-U-4'UUSU 2USU 24UUSU 2USU 24'M GM] US :aKURR"(aSOSnUR/SUS9SU S-U -U -X-S-2==U- ss'SnUUU4$)afComputes gradient and hessian w.r.t. coef. Parameters ---------- coef : ndarray of shape (n_dof,), (n_classes, n_dof) or (n_classes * n_dof,) Coefficients of a linear model. If shape (n_classes * n_dof,), the classes of one feature are contiguous, i.e. one reconstructs the 2d-array via coef.reshape((n_classes, -1), order="F"). X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. y : contiguous array of shape (n_samples,) Observed, true target values. sample_weight : None or contiguous array of shape (n_samples,), default=None Sample weights. l2_reg_strength : float, default=0.0 L2 regularization strength n_threads : int, default=1 Number of OpenMP threads to use. gradient_out : None or ndarray of shape coef.shape A location into which the gradient is stored. If None, a new array might be created. hessian_out : None or ndarray of shape (n_dof, n_dof) or (n_classes * n_dof, n_classes * n_dof) A location into which the hessian is stored. If None, a new array might be created. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). If provided, these are used. If None, then raw_prediction = X @ coef + intercept is calculated. Returns ------- gradient : ndarray of shape coef.shape The gradient of the loss. hessian : ndarray of shape (n_dof, n_dof) or (n_classes, n_dof, n_dof, n_classes) Hessian matrix. hessian_warning : bool True if pointwise hessian has more than 25% of its elements non-positive. Nr%rYz4gradient_out is required to have shape coef.shape = z; got .z"gradient_out must be F-contiguous.rWz'hessian_out is required to have shape (z); got hessian_out.shape=zhessian_out must be contiguous.rMr)r8g?r2Cr4r$)r2r2rZg?F)r rr(r\rrDr9r*rRr^r& ValueErrorr)flags f_contiguoussizer_ c_contiguousgradient_hessianaverageabsrrr6gradient_probar5r`range)r r.rrSrOrHrP gradient_out hessian_outrCrr,r(r-r8r7rTrbnhessrahess_pointwisehessian_warningr'Xhprobaswkhls rrr LinearModelLoss.gradient_hessiansn./WWdnn6N6N*S!3!344  !151J1J41S .G!%!6!6t!< G+3 9N  ==]]#FD   4:: -FtzzlS#))*!- ^^ ) ),2D2D2Q2QAB BD II  88QF'--8D   1a& (9!Q$@&$$&a) ^^ ) )!!..{7H7H7U7U>? ?D~~+++-1^^-L-L-+# .M. *NN f $N f $N  >Q. FM  VVN3N !n 47P PD* !!)--/RT?22-9!^-LD*kzk) *" $zz66C Ru -.R1CPQ .RS#S!!SS>) "SbS"W "R"W -113V %)NN$A$A-+# %B% !NE f $N<< 2#<>D#1#3#3a#7/:S#SDKZK !!,00a08QU yyA~zzz,L("V+6\9%!Q$K1uQT{?3b8!A& .: .:<%%qBI2Y>!.24!.2I2Y>@ /!3Y5Ka5OOPq1ui0Aq!t uQT{2R7A%Q*I2Y>I2Y>@))SS1W 6B%2Q68%2Q6 6BD EEGY3a79ORS9SST8[R"U5n[R"T5(aTRTUST--UST&O2[R R TRTUST/5UST&UST===TUST-- sss&TR(a(UST===UST-- sss&TUST-TUS--US'U$)Nr2)r*r^rrrlinalg multi_dotr) sretrhXhX_sum hessian_sumrHr,r s rhessp7LinearModelLoss.gradient_hessian_product..hesspsmmA&??1%%'(ssb1[j>.A'BC $')yy':':ACCQ{ ^;T'UC $KZ Oa n$DD %% $"6$$q*~5 ae8KKCG rr%rYcP> URTS4SS9nT R(aUSS2S4nUSS2SS24nOSnTUR-U-nUT U-RSS9SS2[R 4-nUT -nT bUT SS2[R 4-n[R "TT4TRSS9nURT-T - TU--USS2ST 24'T R(aURSS9T - USS2S4'TRS:XaURSS9$U$)Nr2r%r4rr$rZrY) r6rrrRr*newaxisr_r&r5r`)r s_intercepttmp hess_prodrr.rHr(r-r,r~rOr rTr8s rrrDs6IIy"oSI9%%"#ArE(K!SbS& A"#K!##g + ((a(0BJJ??u  ,=BJJ77CHHi%7w}}TWX -0UUQY&,@?UVCV,V ![j[.)%%'*wwAw'?Iae$99>$???55$$rr$r4)r rr(r\rrDr*rRr)rrr^r&rrrrrsqueezer= atleast_1drur_r5r`)r r.rrSrOrHrPrr7rCrar{rbrrrrr(r-r,r~rTr8s``` `` @@@@@@@@@rgradient_hessian_product(LinearModelLoss.gradient_hessian_products@./WWdnn6N6N*JS!3!344-1-F-FtQ-O*+3 9N~~+++-1^^-L-L-+# .M. *N f $N f $N==W]];D !n 47P PD* !!)--/R),,.Kq!!$$na%8@VW $ArzzM2Q6!!BJJrvv1v~$>?v.  \{w%)NN$A$A-+# %B% !NE f $N88Y.gmm3OD#1#3#3a#7/G:S#SDKZK !!,00a08QU . % %.yyA~zzz,e33{rrr)Nr3r$N)Nr3r$NNN)Nr3r$)__name__ __module__ __qualname____firstlineno____doc__r!r/r9rDrJrQr]rgrrr__static_attributes__rrrr/sAF+8%"N&2P6:BX~G\+DNOWrr)rnumpyr*scipyrsklearn.utils._array_apirrrsklearn.utils._sparsersklearn.utils.extmathrr rrrrrrs5 7?6o o r