Q(hGBdZddlZddlmZddlmZdZGddZy) zA Loss functions for linear models with raw_prediction = X @ coef N)sparse) squared_normc|jd}tj|r9|jtj|df||fz|zj S|dddf|z}|j|zS)z/Compute the sandwich product X.T @ diag(W) @ X.rshapeN)rrissparseT dia_matrixtoarray)XW n_samplesWXs _/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sklearn/linear_model/_linear_loss.py sandwich_dotrsp I q CC&##QF9i2HI IA M ')  q$wZ!^ssRxc~eZdZdZdZd dZdZdZdZ ddZ dd Z dd Z dd Z dd Z y)LinearModelLossa General 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_features::n_dof] = coef[(n_dof-1)::n_dof] 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 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 c ||_||_yN) base_loss fit_intercept)selfrrs r__init__zLinearModelLoss.__init__hs"*rNc|jd}|jj}|jr|dz}n|}|jjrt j |||f|d}|St j |||}|S)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)rdtypeorder)rr)rr n_classesr is_multiclassnp zeros_like)rr r n_featuresr!n_dofcoefs rinit_zero_coefzLinearModelLoss.init_zero_coefls~ WWQZ NN,,   NEE >> ' '==9e*11rcP|jdk(r||zn t|}d|z|zS)z5Compute L2 penalty term l2_reg_strength/2 *||w||_2^2.rg?)r-r)rr0l2_reg_strengthnorm2_ws r l2_penaltyzLinearModelLoss.l2_penaltys.'.||q'8'G#l7>S_$w..rc||j||\}} }n|j|\}} |jj||d|} t j | |} | |j ||zS)aCompute 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. Ny_truer3 sample_weight n_threadsr0)r4r1rlossr#averager8) rr'r yr<r6r=r3r0r/r?s rr?zLinearModelLoss.losssN  !151J1J4QR1S .GY!%!6!6t!< GY~~"") #  zz$ 6doog???rc|j|jjc\}} } | t|jz} ||j ||\} } }n|j |\} } |jj||||\}}||ntj|}|j|z }||j| |z }||z}|jjs\tj|| j}|j|z|| zz|d| |jr|j|d<||fStj| | f| jd}|j|z|| zz|ddd| f<|jr|jd|dddf<|j d k(r|j#d }||fS) a\Computes 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. Nr:rr*rrr raxisrr,)rrr!intrr4r1 loss_gradientr#sumr8r" empty_likerr emptyr-ravel)rr'r rAr<r6r=r3rr%r!r&r0r/r?grad_pointwisesw_sumgrads rrHzLinearModelLoss.loss_gradient sT./WWdnn6N6N*JS!3!344  !151J1J4QR1S .GY!%!6!6t!< GY#~~;;)' < n ,3 9NxxzF" 99& ~~++==W]];D !n 47P PD* !!)--/RTz88Y.gmm3OD#1#3#3a#7/G:S#SDKZK !!,00a08QU yyA~zzz,TzrcF|j|jjc\}} } | t|jz} ||j ||\} } }n|j |\} } |jj||||}||ntj|}||z}|jjsZtj|| j}|j|z|| zz|d| |jr|j|d<|Stj| | f| jd}|j|z|| zz|ddd| f<|jr|jd|dddf<|jd k(r|j!d S|S) aComputes 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. Nr:rCr*rrDrrErr,)rrr!rGrr4r1gradientr#rIr"rJrr rKr-rL)rr'r rAr<r6r=r3rr%r!r&r0r/rMrNrOs rrQzLinearModelLoss.gradientXsN./WWdnn6N6N*JS!3!344  !151J1J4QR1S .GY!%!6!6t!< GY00)' 1  ,3 9N& ~~++==W]];D !n 47P PD* !!)--/RK88Y.gmm3OD#1#3#3a#7/G:S#SDKZK !!,00a08QU yyA~zzz,, rc $ |j|jjc\} } } | t|jz} | |j ||\}}} n|j |\}}|| ntj|}|#tj||jd}nx|j|jk7r&td|jd|jd|jjr!|jjs td|}|j}|$tj ||f|j}n~|j||fk7rtd ||fd |jd|jjr7|jj"s!|jjs td |}|jjs:|jj%|| || \}}||z}||z}tj&|d k|dkD}tj(|}|j*|z||zz|d| |jr|j|d<|r|||fSt-|||d| d| f<|d kDrA|jj"rdnd}|j/d|d| | z| dzxx|z cc<|jr|j*|z}||dddf<||dddf<|j|d<nj|jj1|| || \}}||z}|j/| | fd}|j*|z||zz|ddd| f<|jr|jd |dddf<|j2dk(r|j5d}|||z }nd|z }t7| D]]}|dd|fd|dd|fz z|z}t-||||| | z| || | z| f<|jrV|j*|z}|||| | z| | | z|zf<||| | z|z|| | z| f<|j|| | z|z| | z|zf<t7|dz| D]}|dd|f |dd|fz|z}t-||||| | z| || | z| f<|jrV|j*|z}|||| | z| | | z|zf<||| | z|z|| | z| f<|j|| | z|z| | z|zf<||d| |d| f||d| |d| f<`|d kDrJ|jj"rdnd}|j/d|d| dz| z| z| | zdzxx|z cc<d}|||fS)a~Computes 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. NrrDz4gradient_out is required to have shape coef.shape = z; got .z"gradient_out must be F-contiguous.rCz'hessian_out is required to have shape (z); got hessian_out.shape=zhessian_out must be contiguous.r:rr>g?r*Cr,r)r*r*rEg?rF)rrr!rGrr4r1r#rIrJr ValueErrorr"flags f_contiguoussizerK c_contiguousgradient_hessianr@absr rr.gradient_probar-rLrange)rr'r rAr<r6r= gradient_out hessian_outr3rr%r!r&r0r/rNrOnhessrMhess_pointwisehessian_warningr Xhprobaswkhls rrZz LinearModelLoss.gradient_hessiansn./WWdnn6N6N*JS!3!344  !151J1J4QR1S .GY!%!6!6t!< GY+3 9N  ==W]]#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 -8zE)eai8$%!!SS>) "SbS"W "R"W -113V %)NN$A$A-+# %B% !NE f $N<<E 2#<>D#1#3#3a#7/G:S#SDKZK !!,00a08QU yyA~zzz,L("V+6\9%, X!Q$K1uQT{?3b8!A& J.: J.:<%%qBI 2Y>!J.24!J.2I 2Y>@ Z/!3Y5Ka5OOPq1ui0XAq!t uQT{2R7A%Q*I 2Y>I 2Y>@))SS1W J 6B% 2Q68% 2Q6 J 6BD EEGY3a7Z9ORS9SST8.hesspsmmA&??1%'(ssb1[j>.A'BC $')yy':':ACCQ{ ^;T'UC $KZ Oa n$DD %% $"6$$q*~5 ae8KKCG rrrDcV |jdfd} jr|dddf}|ddddf}nd}|jz|z}| |zjdddtj fz }| z} | ddtj fz}t j fjd}|jz z |zz|ddd f< jr|jd z |dddf<jdk(r|jdS|S)Nr*rr,rrrErD) r.rr rIr#newaxisrKrr-rL)rn s_intercepttmp hess_prodr r'r6r!r&r%rer<rrNr0s rrsz7LinearModelLoss.gradient_hessian_product..hessps8IIy"oSI9%%"#ArE(K!SbS& A"#K!##g + ))q)1!RZZ-@@u  ,=BJJ77CHHi%7w}}TWX -0UUQY&,@?UVCV,V ![j[.)%%'*wwAw'?Iae$99>$???55$$rrr,)rrr!rGrr4r#rIr"rZrJrr rr r rusqueezeasarray atleast_1dr\rKr-rL)rr'r rAr<r6r=rr/r3rMrbrOrsrprqrrr!r&r%rerNr0s``` `` @@@@@@@@@rgradient_hessian_productz(LinearModelLoss.gradient_hessian_products@./WWdnn6N6N*JS!3!344-1-F-FtQ-O*N+3 9N~~++-1^^-L-L-+# .M. *NN f $N f $N==W]];D !n 47P PD* !!)--/R),,.Kq!%%~q&9)YAWX $ArzzM2Q6!!BJJrvv1v~$>?v.  \U{w%)NN$A$A-+# %B% !NE f $N88Y.gmm3OD#1#3#3a#7/G:S#SDKZK !!,00a08QU . % %.yyA~zzz,e33U{rr)Nr+rN)Nr+rNNN)Nr+r)__name__ __module__ __qualname____doc__rr(r1r4r8r?rHrQrZr|rrrr%s@D+8%"N2@/4@vLfG\+DNOWrr) rnumpyr#scipyr utils.extmathrrrrrrrs&(.T T r