rtjandZddlZddlmZddlmZmZmZddl m Z ddl m Z m Z dZGdd ZdS) 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 |jd}tj|r?tt |jtj|df||f|zdS|dddf|z}|j|zS)z/Compute the sandwich product X.T @ diag(W) @ X.rshapeT) dense_outputN)r rissparserrT dia_array)XW n_samplesWXs _/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sklearn/linear_model/_linear_loss.py sandwich_dotrs I q #  !Q 9/EFFFJ!      qqq$wZ!^sRxceZdZdZdZddZdZdZdZ dd Z dd Z dd Z dd Z ddZ dS)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_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 c"||_||_dSN) base_loss fit_intercept)selfrrs r__init__zLinearModelLoss.__init__ss"*rNc|jd}|jj}|jr|dz}n|}|jjrt j||f|d}nt 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)r dtypeorder)r r#)r r n_classesr is_multiclassnpzeros)rrr# n_featuresr%n_dofcoefs rinit_zero_coefzLinearModelLoss.init_zero_coefwsw WQZ N,   NEEE > ' 689e"4EMMMDD8%u555D rc |jjs|jr|d}|dd}nZd}|}nU|jdkr$||jjdfd}n|}|jr|dddf}|ddddf}nd}||fS)aHelper 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%)rr+ interceptweightss rweight_interceptz LinearModelLoss.weight_intercepts$~+ !  H ss) yA~~,,(@"'ES,QQ! #AAArEN !!!!SbS&/  !!rc||\}}t|\}}}|||j|}|||j|} |jjs ||z| z} n ||jz| z} ||| fS)aiHelper 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)r5rasarrayr#rr&r) rr+rr4r3xp_device_ weights_xp intercept_xpraw_predictions rweight_intercept_rawz$LinearModelLoss.weight_intercept_raws,"224881!44AwZZqwwZGG zz)177zKK ~+ =^l:NN- 11rcj|jdkr||znt|}td|z|zS)z5Compute L2 penalty term l2_reg_strength/2 *||w||_2^2.r!g?)r1r float)rr4l2_reg_strengthnorm2_ws r l2_penaltyzLinearModelLoss.l2_penaltys='.|q'8'8'G##l7>S>SS?*W4555rr/r!c|jd}||||\} } }n||\} } |j||||} t |||\} } ||n| |}t| | |z } |dkr| || |z } | S)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. rNy_truer> sample_weight n_threads) r r?r5rlossrsumrArD)rr+ryrHrBrIr>rr4r3rJr9r:sw_sums rrJzLinearModelLoss.losssNGAJ  !151J1J4QR1S1S .GY!%!6!6t!rr)r%r*r4r3rJgrad_pointwiser9r:rMgradX_gradgrad_Xs rrUzLinearModelLoss.loss_gradient#sST./Wdn6N*JS!3444  !151J1J4QR1S1S .GY!%!6!6t!)F2e4447PP * ! 266.11R 8Y.gm3OOOD#%)F2e4447PP KZK ! %FF>F22r%QQQU yA~~zzz,,Tzrc|j|jjc\}} } | t|jz} ||||\} } }n||\} } |j||||}||ntj |}||z}|jj sPtj || j }|j |z|| zz|d| <|jr| |d<|Stj| | f| j d}|j |z|| zz|ddd| f<|jr| d|dddf<|jd kr|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. NrFrOr.r"rQrrRr!r0)r rr%rTrr?r5gradientr'rKr&rVr#rrWr1rX)rr+rrLrHrBrIr>rr)r%r*r4r3rYrMrZs rr^zLinearModelLoss.gradient}sN./Wdn6N*JS!3444  !151J1J4QR1S1S .GY!%!6!6t!|j jrdnd}|d|d| | z| dzxx|z cc<|jr3|j|z}||dddf<||dddf<||d<nt|j|| || \}}||z}|| | fd}|j|z||zz|ddd| f<|jr|d |dddf<|jdkr|d}|||z }nd|z }t7| D]j}|dd|fd|dd|fz z|z}t-||||| | z| || | z| f<|jrU|j|z}|||| | z| | | z|zf<||| | z|z|| | z| f<||| | z|z| | z|zf<t7|dz| D]}|dd|f |dd|fz|z}t-||||| | z| || | z| f<|jrU|j|z}|||| | z| | | z|zf<||| | z|z|| | z| f<||| | z|z| | z|zf<||d| |d| f||d| |d| f<l|d krG|j jrdnd}|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. Nr"rQz4gradient_out is required to have shape coef.shape = z; got .z"gradient_out must be F-contiguous.rOz'hessian_out is required to have shape (z); got hessian_out.shape=zhessian_out must be contiguous.rFr)r4g?r.Cr0r!)r.r.rRg?F)r rr%rTrr?r5r'rKrVr# ValueErrorr&flags f_contiguoussizerW c_contiguousgradient_hessianaverageabsrrr2gradient_probar1rXrange)rr+rrLrHrBrI gradient_out hessian_outr>rr)r%r*r4r3rMrZnhessrYhess_pointwisehessian_warningr$Xhprobaswkhls rrhz LinearModelLoss.gradient_hessiansn./Wdn6N*JS!3444  !151J1J4QR1S1S .GY!%!6!6t!?? ?D~+b $-1^-L-L-+# .M.. *NN f $N f $N  >Q. FFFM  VN33N !n 47P PD* ! 0)--//R 3T?22-9!^-L-LD*kzk) *"" $z6?C Ru --.Re1CPQ .RSSS#SSS! 4S>) "SbS"W "R"W -1133V %)N$A$A-+# %B%% !NE f $N<<E 2#<>>D#1#3a#7/G:S#SDKZK ! 9,00a088QQQU yA~~zzz,,L("V+6\9%%, X, X!!!Q$K1uQQQT{?3b8!A&& J.: J.:<% qBI 2Y>!J.24!J.2I 2Y>@ Z/!3Y5Ka5OOPq1ui00XXAqqq!t uQQQT{2R7A%Q**I 2Y>I 2Y>@) S1W J 6B% 2Q68% 2Q6 J 6BD EEGGY3a7Z9ORS9SST8.hesspsmA&&?1%%V'(sb1[j[>.A'BC  $$')y':':ACQ{ {^;T'U'UC  $KZK   Oa  n$DD   %L  $$$"6$$$$q*~5 ae8KKCG rr"rQc@ |dfd} jr|dddf}|ddddf}nd}|jz|z}| |zdddtjfz}| z} | ddtjfz}t jfjd}|jz z |zz|ddd f< jr |d z |dddf<jdkr| dS|S)Nr.r"r0rr!rRrQ) r2rrrKr'newaxisrWr#r1rX)r} s_intercepttmp hess_prodrr+rBr%r*r)rtrHrrMr4s rrz7LinearModelLoss.gradient_hessian_product..hesspDsZIIy"oSI99%$"#AAArE(K!!!SbS& AA"#K!#g + ((a(00BJ??u  ,=BJ77CHi%7w}TWXXX -0UQY&,@?UVCV,V !!![j[.)%@'*wwAw'?Iaaae$9>>$???555$$rr!r0)r rr%rTrr?r'rKr&rhrVr#rrrrrsqueezer8 atleast_1drkrWr1rX)rr+rrLrHrBrIrr3r>rYrqrZrrrrr%r*r)rtrMr4s``` `` @@@@@@@@@rgradient_hessian_productz(LinearModelLoss.gradient_hessian_products-@./Wdn6N*JS!3444-1-F-FtQ-O-O*N+3 9N9N~+p 4-1^-L-L-+# .M.. *NN f $N f $N=W];;;D !n 47P PD* ! 0)--//R),,..Kq!! 7$na%8I@VWWW $AAArzM2Q6! /BJrvv1v~~$>$>??v..            &%)N$A$A-+# %B%% !NE f $N8Y.gm3OOOD#1#3a#7/G:S#SDKZK ! 9,00a088QQQU . % % % % % % % % % % % % % % %.yA~~zzz,,e33U{rr)Nr/r!N)Nr/r!NNN)Nr/r!)__name__ __module__ __qualname____doc__rr,r5r?rDrJrUr^rhrrrrr/s2AAF+++8%"%"%"N&2&2&2P666::::BXXXX~GGGG\++++DNOWWWWWWrr)rnumpyr'scipyrsklearn.utils._array_apirrrsklearn.utils._sparsersklearn.utils.extmathrr rrrrrrs 766666????????6o o o o o o o o o o r