:j >dZddlZddlZddlmZddlmZmZm Z m Z m Z m Z m Z mZmZmZmZddlmZmZmZmZmZmZddlmZddlmZddlmZmZm Z dd l!m"Z"dd l#m$Z$Gd d Z%Gd de%Z&Gdde%Z'Gdde%Z(Gdde%Z)Gdde%Z*Gdde%Z+Gdde%Z,Gdde%Z-Gdde%Z.Gdd e%Z/Gd!d"e%Z0e&e'e(e)e*e+e,e.e/e0d# Z1Gd$d%Z2d&Z3Gd'd(e2e.Z4Gd)d*e2e/Z5Gd+d,e2e*Z6y)-z This module contains loss classes suitable for fitting. It is not part of the public API. Specific losses are used for regression, binary classification or multiclass classification. Nxlogy) CyAbsoluteErrorCyExponentialLossCyHalfBinomialLossCyHalfGammaLossCyHalfMultinomialLossCyHalfPoissonLossCyHalfSquaredErrorCyHalfTweedieLossCyHalfTweedieLossIdentity CyHuberLoss CyPinballLoss) HalfLogitLink IdentityLinkInterval LogitLinkLogLinkMultinomialLogit)one_hot) check_scalar)_average _logsumexp_ravel)softmax)_weighted_percentileceZdZdZdZdZddZdZdZ ddZ dd Z dd Z dd Z dd Z dd ZddZej"dfdZy)BaseLossaBase class for a loss function of 1-dimensional targets. Conventions: - y_true.shape = sample_weight.shape = (n_samples,) - y_pred.shape = raw_prediction.shape = (n_samples,) - If is_multiclass is true (multiclass classification), then y_pred.shape = raw_prediction.shape = (n_samples, n_classes) Note that this corresponds to the return value of decision_function. y_true, y_pred, sample_weight and raw_prediction must either be all float64 or all float32. gradient and hessian must be either both float64 or both float32. Note that y_pred = link.inverse(raw_prediction). Specific loss classes can inherit specific link classes to satisfy BaseLink's abstractmethods. Parameters ---------- closs: CyLossFunction For example, a CyLossFunction; hence the name "c"loss. link : BaseLink sample_weight : {None, ndarray} If sample_weight is None, the hessian might be constant. n_classes : {None, int} The number of classes for classification, else None. xp : module, default=None Array namespace module. device : device, default=None A device object (see the "Device Support" section of the array API spec). Attributes ---------- closs: CyLossFunction For example, a CyLossFunction; hence the name "c"loss. link : BaseLink n_classes : {None, int} The number of classes for classification, else None. xp : module or None Array namespace module. Ignored by the Cython implementation. device : device or None A device object. Ignored by the Cython implementation. interval_y_true : Interval Valid interval for y_true interval_y_pred : Interval Valid Interval for y_pred differentiable : bool Indicates whether or not loss function is differentiable in raw_prediction everywhere. approx_hessian : bool Indicates whether the hessian is approximated or exact. If, approximated, it should be larger or equal to the exact one. constant_hessian : bool Indicates whether the hessian is one for this loss. is_multiclass : bool Indicates whether n_classes > 2 is allowed. TFNc||_||_||_||_||_d|_d|_ttj tjdd|_ |jj|_ y)NF) closslink n_classesxpdeviceapprox_hessianconstant_hessianrnpinfinterval_y_trueinterval_y_pred)selfr r!r"r#r$s g/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/sklearn/_loss/loss.py__init__zBaseLoss.__init__sd  " # %'F#yy88c8|jj|SzuReturn True if y is in the valid range of y_true. Parameters ---------- y : ndarray )r)includesr+ys r,in_y_true_rangezBaseLoss.in_y_true_range##,,Q//r.c8|jj|S)zuReturn True if y is in the valid range of y_pred. Parameters ---------- y : ndarray )r*r1r2s r,in_y_pred_rangezBaseLoss.in_y_pred_ranger5r.c|tj|}|jdk(r#|jddk(r|j d}|j j ||||||S)aJCompute the pointwise loss value for each input. Parameters ---------- y_true : C-contiguous array of shape (n_samples,) Observed, true target values. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). sample_weight : None or C-contiguous array of shape (n_samples,) Sample weights. loss_out : None or C-contiguous array of shape (n_samples,) A location into which the result is stored. If None, a new array might be created. n_threads : int, default=1 Might use openmp thread parallelism. Returns ------- loss : array of shape (n_samples,) Element-wise loss function. y_trueraw_prediction sample_weightloss_out n_threads)r' empty_likendimshapesqueezer lossr+r<r=r>r?r@s r,rEz BaseLoss.lossss<  }}V,H   ! #(<(r? gradient_outr@)r'rArIrBrCrDr loss_gradient)r+r<r=r>r?rJr@s r,rKzBaseLoss.loss_gradientsL  #==0!}}^< ==|7I7IJ  !==x~~NL   ! #(<(rJr@)r'rArBrCrDr gradientr+r<r=r>rJr@s r,rMzBaseLoss.gradients>  ==8L   ! #(<(rJ hessian_outr@)r'rArBrCrDr gradient_hessian)r+r<r=r>rJrPr@s r,rQzBaseLoss.gradient_hessianPsN  "!}}^<  mmN; !}}[9  -- 5K   ! #(<(%--a0K ##)'%# $ [((r.c Xtj|j||dd||S)a{Compute the weighted average loss. Parameters ---------- y_true : C-contiguous array of shape (n_samples,) Observed, true target values. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). sample_weight : None or C-contiguous array of shape (n_samples,) Sample weights. n_threads : int, default=1 Might use openmp thread parallelism. Returns ------- loss : float Mean or averaged loss function. Nr;weights)r'averagerE)r+r<r=r>r@s r,__call__zBaseLoss.__call__s:(zz II-"#  "  r.ctj||d}dtj|jjz}|j j tj k(rd}nF|j jr|j j }n|j j |z}|j jtjk(rd}nF|j jr|j j}n|j j|z }|||jj|S|jjtj|||S)a#Compute raw_prediction of an intercept-only model. This can be used as initial estimates of predictions, i.e. before the first iteration in fit. Parameters ---------- y_true : array-like of shape (n_samples,) Observed, true target values. sample_weight : None or array of shape (n_samples,) Sample weights. Returns ------- raw_prediction : numpy scalar or array of shape (n_classes,) Raw predictions of an intercept-only model. rrTaxis N) r'rUfinforIepsr*lowr( low_inclusivehighhigh_inclusiver!clip)r+r<r>y_predr\a_mina_maxs r,fit_intercept_onlyzBaseLoss.fit_intercept_onlys(FMB288FLL)---    # #w .E  ! ! / /((,,E((,,s2E    $ $ .E  ! ! 0 0((--E((--3E =U]99>>&) )99>>"''&%"?@ @r.c,tj|S)a(Calculate term dropped in loss. With this term added, the loss of perfect predictions is zero. Parameters ---------- y_true : array-like of shape (n_samples,) Observed, true target values. sample_weight : None or array of shape (n_samples,), default=None Sample weights. Returns ------- constant : ndarray of shape (n_samples,) Constant value to be added to raw predictions so that the loss of perfect predictions becomes zero. )r' zeros_liker+r<r>s r,constant_to_optimal_zeroz!BaseLoss.constant_to_optimal_zeros&}}V$$r.FcV|tjtjfvrtd|d|jr||j f}n|f}tj |||}|jrtjd|}||fStj |||}||fS)auInitialize arrays for gradients and hessians. Unless hessians are constant, arrays are initialized with undefined values. Parameters ---------- n_samples : int The number of samples, usually passed to `fit()`. dtype : {np.float64, np.float32}, default=np.float64 The dtype of the arrays gradient and hessian. order : {'C', 'F'}, default='F' Order of the arrays gradient and hessian. The default 'F' makes the arrays contiguous along samples. Returns ------- gradient : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Empty array (allocated but not initialized) to be used as argument gradient_out. hessian : C-contiguous array of shape (n_samples,), array of shape (n_samples, n_classes) or shape (1,) Empty (allocated but not initialized) array to be used as argument hessian_out. If constant_hessian is True (e.g. `HalfSquaredError`), the array is initialized to ``1``. zCValid options for 'dtype' are np.float32 and np.float64. Got dtype=z instead.)rCrIorder)r:)rCrI) r'float32float64 ValueError is_multiclassr"emptyr&ones)r+ n_samplesrIrlrCrMhessians r,init_gradient_and_hessianz"BaseLoss.init_gradient_and_hessians8 RZZ0 0"G9.    /ELE88%uEB  ggD6G  hhU%uEG  r.NNNNNr:NNNr:Nr:N)__name__ __module__ __qualname____doc__differentiablerpr-r4r7rErKrMrQrVrerir'rnrur.r,rrMs:JNM 900 +b=&F /j@)D >(AT%*:<31!r.rc$eZdZdZdfd ZxZS)HalfSquaredErroraHalf squared error with identity link, for regression. Domain: y_true and y_pred all real numbers Link: y_pred = raw_prediction For a given sample x_i, half squared error is defined as:: loss(x_i) = 0.5 * (y_true_i - raw_prediction_i)**2 The factor of 0.5 simplifies the computation of gradients and results in a unit hessian (and is consistent with what is done in LightGBM). It is also half the Normal distribution deviance. c^t|tt|||du|_y)Nr r!r#r$)superr-r rr&r+r>r#r$ __class__s r,r-zHalfSquaredError.__init__6s2 $&\^6  !. 5r.rvr{r|r}r~r- __classcell__rs@r,rr$s"66r.rc0eZdZdZdZdfd ZddZxZS) AbsoluteErroraAbsolute error with identity link, for regression. Domain: y_true and y_pred all real numbers Link: y_pred = raw_prediction For a given sample x_i, the absolute error is defined as:: loss(x_i) = |y_true_i - raw_prediction_i| Note that the exact hessian = 0 almost everywhere (except at one point, therefore differentiable = False). Optimization routines like in HGBT, however, need a hessian > 0. Therefore, we assign 1. Fclt|tt||d|_|du|_y)NrT)rr-rrr%r&rs r,r-zAbsoluteError.__init__Qs: !#,.R  # - 5r.cN|tj|dSt||dS)Compute raw_prediction of an intercept-only model. This is the weighted median of the target, i.e. over the samples axis=0. rrY2)r'medianrrhs r,rez AbsoluteError.fit_intercept_onlyXs*  99V!, ,' rB Br.rvrzr{r|r}r~rr-rerrs@r,rr=s"N6 Cr.rc0eZdZdZdZdfd ZddZxZS) PinballLossaQuantile loss aka pinball loss, for regression. Domain: y_true and y_pred all real numbers quantile in (0, 1) Link: y_pred = raw_prediction For a given sample x_i, the pinball loss is defined as:: loss(x_i) = rho_{quantile}(y_true_i - raw_prediction_i) rho_{quantile}(u) = u * (quantile - 1_{u<0}) = -u *(1 - quantile) if u < 0 u * quantile if u >= 0 Note: 2 * PinballLoss(quantile=0.5) equals AbsoluteError(). Note that the exact hessian = 0 almost everywhere (except at one point, therefore differentiable = False). Optimization routines like in HGBT, however, need a hessian > 0. Therefore, we assign 1. Additional Attributes --------------------- quantile : float The quantile level of the quantile to be estimated. Must be in range (0, 1). Fct|dtjdddt|t t |t||d|_|du|_ y) Nquantilerr:neither target_typemin_valmax_valinclude_boundaries)rrT) rnumbersRealrr-rfloatrr%r&)r+r>rr#r$rs r,r-zPinballLoss.__init__sc   (   x9  # - 5r.c|/tj|d|jjzdSt ||d|jjzS)rdrr)r' percentiler rrrhs r,rezPinballLoss.fit_intercept_onlysO  ==tzz/B/B)BK K' sTZZ-@-@'@ r.)N?NNrzrrs@r,rrds:N6$ r.rc2eZdZdZdZ dfd ZddZxZS) HuberLossaHuber loss, for regression. Domain: y_true and y_pred all real numbers quantile in (0, 1) Link: y_pred = raw_prediction For a given sample x_i, the Huber loss is defined as:: loss(x_i) = 1/2 * abserr**2 if abserr <= delta delta * (abserr - delta/2) if abserr > delta abserr = |y_true_i - raw_prediction_i| delta = quantile(abserr, self.quantile) Note: HuberLoss(quantile=1) equals HalfSquaredError and HuberLoss(quantile=0) equals delta * (AbsoluteError() - delta/2). Additional Attributes --------------------- quantile : float The quantile level which defines the breaking point `delta` to distinguish between absolute error and squared error. Must be in range (0, 1). Reference --------- .. [1] Friedman, J.H. (2001). :doi:`Greedy function approximation: A gradient boosting machine <10.1214/aos/1013203451>`. Annals of Statistics, 29, 1189-1232. Fct|dtjddd||_t|t t|t||d|_ d |_ y) Nrrr:rr)deltarTF) rrrrrr-rrrr%r&)r+r>rrr#r$rs r,r-zHuberLoss.__init__sg    (  !  E%L1  # %r.c6|tj|dd}n t||d}||z }tj|tj|j j tj|z}|tj||zS)rrrrrS) r'rrsignminimumr rabsrU)r+r<r>rdiffterms r,rezHuberLoss.fit_intercept_onlysx  ]]62A6F)&-DFwwt}rzz$***:*:BFF4LII 4???r.)Ng?rNNrzrrs@r,rrs"BNLP&*@r.rc,eZdZdZdfd ZddZxZS)HalfPoissonLossaHalf Poisson deviance loss with log-link, for regression. Domain: y_true in non-negative real numbers y_pred in positive real numbers Link: y_pred = exp(raw_prediction) For a given sample x_i, half the Poisson deviance is defined as:: loss(x_i) = y_true_i * log(y_true_i/exp(raw_prediction_i)) - y_true_i + exp(raw_prediction_i) Half the Poisson deviance is actually the negative log-likelihood up to constant terms (not involving raw_prediction) and simplifies the computation of the gradients. We also skip the constant term `y_true_i * log(y_true_i) - y_true_i`. ct|tt||t dt j dd|_y)NrrTF)rr-r rrr'r(r)rs r,r-zHalfPoissonLoss.__init__s< #%GI"V   (2664?r.c2t|||z }|||z}|Srzrr+r<r>rs r,riz(HalfPoissonLoss.constant_to_optimal_zero s(VV$v-  $ M !D r.rvrzr{r|r}r~r-rirrs@r,rrs(@ r.rc,eZdZdZdfd ZddZxZS) HalfGammaLossaVHalf Gamma deviance loss with log-link, for regression. Domain: y_true and y_pred in positive real numbers Link: y_pred = exp(raw_prediction) For a given sample x_i, half Gamma deviance loss is defined as:: loss(x_i) = log(exp(raw_prediction_i)/y_true_i) + y_true/exp(raw_prediction_i) - 1 Half the Gamma deviance is actually proportional to the negative log- likelihood up to constant terms (not involving raw_prediction) and simplifies the computation of the gradients. We also skip the constant term `-log(y_true_i) - 1`. ct|tt||t dt j dd|_y)NrrF)rr-rrrr'r(r)rs r,r-zHalfGammaLoss.__init__&s6 0wyRPVW'2665%@r.cFtj| dz }|||z}|Sry)r'logrs r,riz&HalfGammaLoss.constant_to_optimal_zero*s+v"  $ M !D r.rvrzrrs@r,rrs&Ar.rc,eZdZdZdfd ZddZxZS)HalfTweedieLossaHalf Tweedie deviance loss with log-link, for regression. Domain: y_true in real numbers for power <= 0 y_true in non-negative real numbers for 0 < power < 2 y_true in positive real numbers for 2 <= power y_pred in positive real numbers power in real numbers Link: y_pred = exp(raw_prediction) For a given sample x_i, half Tweedie deviance loss with p=power is defined as:: loss(x_i) = max(y_true_i, 0)**(2-p) / (1-p) / (2-p) - y_true_i * exp(raw_prediction_i)**(1-p) / (1-p) + exp(raw_prediction_i)**(2-p) / (2-p) Taking the limits for p=0, 1, 2 gives HalfSquaredError with a log link, HalfPoissonLoss and HalfGammaLoss. We also skip constant terms, but those are different for p=0, 1, 2. Therefore, the loss is not continuous in `power`. Note furthermore that although no Tweedie distribution exists for 0 < power < 1, it still gives a strictly consistent scoring function for the expectation. ct|tt|t |||j j dkr1ttj tjdd|_ y|j j dkr"tdtjdd|_ ytdtjdd|_ yN)powerrrFr9T) rr-r rrr rrr'r(r)r+r>rr#r$rs r,r-zHalfTweedieLoss.__init__Ps #%,7  ::  q #+RVVGRVVUE#JD ZZ   !#+ArvvtU#CD #+Arvvue#DD r.c|jjdk(rtj||S|jjdk(rt j||S|jjdk(rt j||S|jj}t jt j|dd|z d|z z d|z z }|||z}|S)Nr)r<r>r:r9)r rrrirrr'maximum)r+r<r>prs r,riz(HalfTweedieLoss.constant_to_optimal_zero^s ::  q #%>>]? ZZ   ""$==]> ZZ   " ?;;]<    A88BJJvq11q59QUCq1uMD( %Kr.Ng?NNrzrrs@r,rr1s< Er.rc$eZdZdZdfd ZxZS)HalfTweedieLossIdentityanHalf Tweedie deviance loss with identity link, for regression. Domain: y_true in real numbers for power <= 0 y_true in non-negative real numbers for 0 < power < 2 y_true in positive real numbers for 2 <= power y_pred in positive real numbers for power != 0 y_pred in real numbers for power = 0 power in real numbers Link: y_pred = raw_prediction For a given sample x_i, half Tweedie deviance loss with p=power is defined as:: loss(x_i) = max(y_true_i, 0)**(2-p) / (1-p) / (2-p) - y_true_i * raw_prediction_i**(1-p) / (1-p) + raw_prediction_i**(2-p) / (2-p) Note that the minimum value of this loss is 0. Note furthermore that although no Tweedie distribution exists for 0 < power < 1, it still gives a strictly consistent scoring function for the expectation. ct|tt|t |||j j dkr1ttj tjdd|_ n\|j j dkr"tdtjdd|_ n!tdtjdd|_ |j j dk(r1ttj tjdd|_ ytdtjdd|_ yr) rr-r rrr rrr'r(r)r*rs r,r-z HalfTweedieLossIdentity.__init__s +%,?  ::  q #+RVVGRVVUE#JD ZZ   !#+ArvvtU#CD #+Arvvue#DD ::  q #+RVVGRVVUE#JD #+Arvvue#DD r.rrrs@r,rrss6EEr.rc2eZdZdZdfd ZddZdZxZS)HalfBinomialLossaYHalf Binomial deviance loss with logit link, for binary classification. This is also know as binary cross entropy, log-loss and logistic loss. Domain: y_true in [0, 1], i.e. regression on the unit interval y_pred in (0, 1), i.e. boundaries excluded Link: y_pred = expit(raw_prediction) For a given sample x_i, half Binomial deviance is defined as the negative log-likelihood of the Binomial/Bernoulli distribution and can be expressed as:: loss(x_i) = log(1 + exp(raw_pred_i)) - y_true_i * raw_pred_i See The Elements of Statistical Learning, by Hastie, Tibshirani, Friedman, section 4.4.1 (about logistic regression). Note that the formulation works for classification, y = {0, 1}, as well as logistic regression, y = [0, 1]. If you add `constant_to_optimal_zero` to the loss, you get half the Bernoulli/binomial deviance. More details: Inserting the predicted probability y_pred = expit(raw_prediction) in the loss gives the well known:: loss(x_i) = - y_true_i * log(y_pred_i) - (1 - y_true_i) * log(1 - y_pred_i) ctt|ttd||t dddd|_yNr9r r!r"r#r$rr:T)rr-rrrr)rs r,r-zHalfBinomialLoss.__init__s> $&   (1dD9r.cRt||td|z d|z z}|||z}|Sryrrs r,riz)HalfBinomialLoss.constant_to_optimal_zeros7VV$uQZV'DD  $ M !D r.c4|jdk(r#|jddk(r|jd}tj|jddf|j }|j j||dddf<d|dddfz |dddf<|Sa=Predict probabilities. Parameters ---------- raw_prediction : array of shape (n_samples,) or (n_samples, 1) Raw prediction values (in link space). Returns ------- proba : array of shape (n_samples, 2) Element-wise class probabilities. r9r:rrHNrBrCrDr'rqrIr!inverser+r=probas r, predict_probazHalfBinomialLoss.predict_proba   ! #(<(:r.rcLeZdZdZdZdfd ZdZd dZdZ d dZ xZ S) HalfMultinomialLossa/Categorical cross-entropy loss, for multiclass classification. Domain: y_true in {0, 1, 2, 3, .., n_classes - 1} y_pred has n_classes elements, each element in (0, 1) Link: y_pred = softmax(raw_prediction) Note: We assume y_true to be already label encoded. The inverse link is softmax. But the full link function is the symmetric multinomial logit function. For a given sample x_i, the categorical cross-entropy loss is defined as the negative log-likelihood of the multinomial distribution, it generalizes the binary cross-entropy to more than 2 classes:: loss_i = log(sum(exp(raw_pred_{i, k}), k=0..n_classes-1)) - sum(y_true_{i, k} * raw_pred_{i, k}, k=0..n_classes-1) See [1]. Note that for the hessian, we calculate only the diagonal part in the classes: If the full hessian for classes k and l and sample i is H_i_k_l, we calculate H_i_k_k, i.e. k=l. Parameters ---------- sample_weight : {None, ndarray} If sample_weight is None, the hessian might be constant. n_classes : {None, int} The number of classes for classification, else None. xp : module or None Array namespace module. Ignored by the Cython implementation. device : device or None A device object. Ignored by the Cython implementation. References ---------- .. [1] :arxiv:`Simon, Noah, J. Friedman and T. Hastie. "A Blockwise Descent Algorithm for Group-penalized Multiresponse and Multinomial Regression". <1311.6529>` Tct|tt|||t dt j dd|_t dddd|_d|_ d|_ d|_ y)NrrTFr:) rr-r rrr'r(r)r*class_indexing_offsets y_true_inty_true_one_hotr+r>r"r#r$rs r,r-zHalfMultinomialLoss.__init__so ')!#   (2664?'1eU;'+#"r.c|jj|xr+tj|j t |k(Sr0)r)r1r'allastypeintr2s r,r4z#HalfMultinomialLoss.in_y_true_range.s6##,,Q/NBFF188C=A;M4NNr.ctj|j|j}tj|jj }t |jD]@}tj||k(|d||<tj|||d|z ||<B|jj|dddfjdS)a-Compute raw_prediction of an intercept-only model. This is the softmax of the weighted average of the target, i.e. over the samples axis=0. Parameters ---------- y_true : array-like of shape (n_samples,) Observed, true target values. sample_weight : None or array of shape (n_samples,), default=None Sample weights. Returns ------- raw_prediction : numpy scalar or array of shape (n_classes,) Raw predictions of an intercept-only model. rHrrXr:N) r'zerosr"rIr[r\rangerUrar!reshape)r+r<r>outr\ks r,rez&HalfMultinomialLoss.fit_intercept_only7s&hht~~V\\:hhv||$((t~~& 3AZZ! ]KCFWWSVS!c'2CF 3yy~~c$'l+33B77r.c8|jj|S)a=Predict probabilities. Parameters ---------- raw_prediction : array of shape (n_samples, n_classes) Raw prediction values (in link space). Returns ------- proba : array of shape (n_samples, n_classes) Element-wise class probabilities. )r!r)r+r=s r,rz!HalfMultinomialLoss.predict_probaQsyy  00r.c|C|+tj|}tj|}n-tj|}n|tj|}|jj||||||||fS)aKCompute gradient and class probabilities fow raw_prediction. Parameters ---------- y_true : C-contiguous array of shape (n_samples,) Observed, true target values. raw_prediction : array of shape (n_samples, n_classes) Raw prediction values (in link space). sample_weight : None or C-contiguous array of shape (n_samples,) Sample weights. gradient_out : None or array of shape (n_samples, n_classes) A location into which the gradient is stored. If None, a new array might be created. proba_out : None or array of shape (n_samples, n_classes) A location into which the class probabilities are stored. If None, a new array might be created. n_threads : int, default=1 Might use openmp thread parallelism. Returns ------- gradient : array of shape (n_samples, n_classes) Element-wise gradients. proba : array of shape (n_samples, n_classes) Element-wise class probabilities. )r<r=r>rJ proba_outr@)r'rAr gradient_proba)r+r<r=r>rJrr@s r,rz"HalfMultinomialLoss.gradient_proba`sH   !}}^< MM.9 !}}Y7   l3I !!)'% " Y&&r.NNNrzrx) r{r|r}r~rpr-r4rerrrrs@r,rrs8.`M#"O84 1&5'r.rc2eZdZdZdfd ZddZdZxZS)ExponentialLossa"Exponential loss with (half) logit link, for binary classification. This is also know as boosting loss. Domain: y_true in [0, 1], i.e. regression on the unit interval y_pred in (0, 1), i.e. boundaries excluded Link: y_pred = expit(2 * raw_prediction) For a given sample x_i, the exponential loss is defined as:: loss(x_i) = y_true_i * exp(-raw_pred_i)) + (1 - y_true_i) * exp(raw_pred_i) See: - J. Friedman, T. Hastie, R. Tibshirani. "Additive logistic regression: a statistical view of boosting (With discussion and a rejoinder by the authors)." Ann. Statist. 28 (2) 337 - 407, April 2000. https://doi.org/10.1214/aos/1016218223 - A. Buja, W. Stuetzle, Y. Shen. (2005). "Loss Functions for Binary Class Probability Estimation and Classification: Structure and Applications." Note that the formulation works for classification, y = {0, 1}, as well as "exponential logistic" regression, y = [0, 1]. Note that this is a proper scoring rule, but without it's canonical link. More details: Inserting the predicted probability y_pred = expit(2 * raw_prediction) in the loss gives:: loss(x_i) = y_true_i * sqrt((1 - y_pred_i) / y_pred_i) + (1 - y_true_i) * sqrt(y_pred_i / (1 - y_pred_i)) ctt|ttd||t dddd|_yr)rr-rrrr)rs r,r-zExponentialLoss.__init__s> #%   (1dD9r.cPdtj|d|z zz}|||z}|S)Nr:)r'sqrtrs r,riz(ExponentialLoss.constant_to_optimal_zeros3BGGFa&j122  $ M !D r.c4|jdk(r#|jddk(r|jd}tj|jddf|j }|j j||dddf<d|dddfz |dddf<|Srrrs r,rzExponentialLoss.predict_probarr.rvrzrrs@r,rrs!F:r.r) squared_errorabsolute_error pinball_loss huber_loss poisson_loss gamma_loss tweedie_loss binomial_lossmultinomial_lossexponential_losscHeZdZdZ ddZ ddZ d dZ ddZy) ArrayAPILossMixinaMixin for loss classes that are compatible with the array API. Currently this mixin redefines methods: - __call__(...) - loss(...) - loss_gradient(...) - gradient(...) such that they work according to the array API specification. It uses the attributes self.xp and self.device from BaseLoss and it assumes that methods self._compute_loss and self._compute_gradient are implemented. Ncl|j||d}tt|||jS)aCompute the weighted average loss for the array API losses. Parameters ---------- y_true : C-contiguous array of shape (n_samples,) Observed, true target values. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). sample_weight : None or C-contiguous array of shape (n_samples,) Sample weights. n_threads : int, default=1 Ignored by the array API implementation. Returns ------- loss : float Mean or averaged loss function. Nr<r=r>)rTr#)rErrr#)r+r<r=r>r@loss_xps r,rVzArrayAPILossMixin.__call__s84)). Xg}IJJr.c*|j|||S)aCompute the pointwise loss value for each input. Parameters ---------- y_true : C-contiguous array of shape (n_samples,) Observed, true target values. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). sample_weight : None or C-contiguous array of shape (n_samples,) Sample weights. loss_out : None or C-contiguous array of shape (n_samples,) Ignored by the array API implementation. n_threads : int, default=1 Ignored by the array API implementation. Returns ------- loss : array of shape (n_samples,) Element-wise loss function. r) _compute_lossrFs r,rEzArrayAPILossMixin.losss%:!!)'"  r.cZ|j|||}|j|||}||fS)aGCompute loss and gradient w.r.t. raw_prediction for each input. Parameters ---------- y_true : C-contiguous array of shape (n_samples,) Observed, true target values. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). sample_weight : None or C-contiguous array of shape (n_samples,) Sample weights. loss_out : None or C-contiguous array of shape (n_samples,) Ignored by the array API implementation. gradient_out : None or C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Ignored by the array API implementation. n_threads : int, default=1 Ignored by the array API implementation. Returns ------- loss : array of shape (n_samples,) Element-wise loss function. gradient : array of shape (n_samples,) or (n_samples, n_classes) Element-wise gradients. r)r_compute_gradient) r+r<r=r>r?rJr@rErMs r,rKzArrayAPILossMixin.loss_gradientAsOH!!)'"  )))'*  X~r.c*|j|||S)axCompute gradient of loss w.r.t raw_prediction for each input. Parameters ---------- y_true : C-contiguous array of shape (n_samples,) Observed, true target values. raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). sample_weight : None or C-contiguous array of shape (n_samples,) Sample weights. gradient_out : None or C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Ignored by the array API implementation. n_threads : int, default=1 Ignored by the array API implementation. Returns ------- gradient : array of shape (n_samples,) or (n_samples, n_classes) Element-wise gradients. r)rrNs r,rMzArrayAPILossMixin.gradientqs%<%%)'&  r.ryrwrx)r{r|r}r~rVrErKrMrr.r,rrsK " KF ! N.h " r.rcN|j|jk(rgdngd}|j||dk||j||dk|j||j||dk|j d|z|j||dk|d|z z|S)anNumerically stable version of log(1 + exp(x)) that is compatible with the array API. Parameters ---------- raw_prediction : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Raw prediction values (in link space). raw_prediction_exp : C-contiguous array of shape (n_samples,) or array of shape (n_samples, n_classes) Exponential of the raw prediction values. xp : module, default=None Array namespace module. Returns ------- log1pexp : float Numerically stable value for log(1 + exp(raw_prediction)). )rgfffff@@)r g333333-@rr:r9g?r)rIrnwherelog1pr)r=raw_prediction_expr# constantss r, _log1pexprsj   2:: -   88)A,&  il * HH' ( HH)A,.s//0"il2"Q);%;;"   r.c8eZdZdZ ddZ ddZ ddZy)HalfBinomialLossArrayAPIzHA version of the HalfBinomialLoss that is compatible with the array API.Nc|jj|}|j||||}|j||||} || fSN)r<r=r>rr#exprr r+r<r=r>r?rJr@rrErMs r,rKz&HalfBinomialLossArrayAPI.loss_gradientg"WW[[8!!)'1 "  )))'1 *  X~r.c||jj|}t|||j}|||zz }|||z}|S)N)r=rr#)r#rr)r+r<r=r>rlog1pexprEs r,rz&HalfBinomialLossArrayAPI._compute_losssZ  %!%^!< )1ww  &>11  $ M !D r.c|j}||j|}d|z }|j||j|jk(rdndkDd|z ||zz d|zz ||z }|||z}|S)Nr:r r )r#rrrIrn)r+r<r=r>rr#neg_raw_prediction_expgrads r,rz*HalfBinomialLossArrayAPI._compute_gradientsWW  %!#!7 !"%7!7xx ^%9%9RZZ%GcS Q&jF%;; ;)) +  '    $ M !D r.rxNNr{r|r}r~rKrrrr.r,rrs2R 8 . r.rc8eZdZdZdfd Z ddZ ddZxZS)HalfMultinomialLossArrayAPIaA version of the HalfMultinomialLoss that is compatible with the array API. Parameters ---------- sample_weight : {None, ndarray} If sample_weight is None, the hessian might be constant. n_classes : {None, int} The number of classes for classification, else None. xp : module or None Array namespace module. device : device or None A device object. cTt||||d|_d|_d|_y)N)r"r#r$)rr-rrrrs r,r-z$HalfMultinomialLossArrayAPI.__init__7s2 9FC '+##r.c|j}|j}t|d|}|j#|j ||j ||_|j 2|j|jd||jz|_|jt||j|j z}||z }|||z}|S)Nr:)rYr#rIr$r)r$) r#r$rrasarrayint64rarangerCr"taker) r+r<r=r>r#r$ log_sum_exptrue_label_probsrEs r,rz)HalfMultinomialLossArrayAPI._compute_lossDs WW aB? ?? " jjrxxjODO  & & . &,,q/& 9DNNJ  '77 > "DOOd6Q6Q$Q --  $ M !D r.c^|j}|j}|j`|j#|j ||j ||_t |j|j|j|_t|}||jz}| ||dddfz}|S)Nr&) num_classesrI) r#r$rrr'r(rr"rIr)r+r<r=r>r#device_rs r,rz-HalfMultinomialLossArrayAPI._compute_gradient\s WW++    &&"$**V288G*"T") NN$**#D  ~& ###  $ M!T'* *D r.rrz)r{r|r}r~r-rrrrs@r,r#r#%s!" #" 8 r.r#c8eZdZdZ ddZ ddZ ddZy)HalfPoissonLossArrayAPIzGA version of the HalfPoissonLoss that is compatible with the array API.Nc|jj|}|j||||}|j||||} || fSrrrs r,rKz%HalfPoissonLossArrayAPI.loss_gradientrr.c^||jj|}|||zz }|||z}|Srzr#r)r+r<r=r>rrEs r,rz%HalfPoissonLossArrayAPI._compute_losssA  %!%^!< !F^$;;  $ M !D r.cX||jj|}||z }|||z}|Srzr4)r+r<r=r>rrs r,rz)HalfPoissonLossArrayAPI._compute_gradients<  %!%^!< !F*  $ M !D r.rxr r!rr.r,r1r1}s2Q 8 $ r.r1)7r~rnumpyr' scipy.specialrsklearn._loss._lossrrrrr r r r r rrsklearn._loss.linkrrrrrr!sklearn.externals.array_api_extrar sklearn.utilsrsklearn.utils._array_apirrrsklearn.utils.extmathrsklearn.utils.statsrrrrrrrrrrrrr_LOSSESrrrr#r1rr.r,r@se*    6& *4*T!T!n6x62$CH$CN=(=@I@I@XhDH>?h?D-Eh-E`DxDNk'(k'\HhHX&###%+' b b JHVA02BAHU"35HUp5/5r.