Mpj >SrSSKrSSKrSSKJr SSKJrJrJ r J r J r J r J r JrJrJrJr SSKJrJrJrJrJrJr SSKJr SSKJr SSKJrJrJ r SS K!J"r" SS K#J$r$ "S S 5r%"S S\%5r&"SS\%5r'"SS\%5r("SS\%5r)"SS\%5r*"SS\%5r+"SS\%5r,"SS\%5r-"SS\%5r."SS \%5r/"S!S"\%5r0\&\'\(\)\*\+\,\.\/\0S#. r1"S$S%5r2S&r3"S'S(\2\.5r4"S)S*\2\/5r5"S+S,\2\*5r6g)-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_percentilec\rSrSrSrSrSrSSjrSrSr SS jr SS jr SS jr SS jr SS jrSSjrSSjr\R$S4SjrSrg)BaseLossMaBase 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. TFNcXlX lX0lX@lXPlSUlSUl[[R*[RSS5Ul URRUl g)NF) closslink n_classesxpdeviceapprox_hessianconstant_hessianrnpinfinterval_y_trueinterval_y_pred)selfr!r"r#r$r%s N/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/sklearn/_loss/loss.py__init__BaseLoss.__init__sZ  " # %'F#yy88c8URRU5$zUReturn True if y is in the valid range of y_true. Parameters ---------- y : ndarray )r*includesr,ys r-in_y_true_rangeBaseLoss.in_y_true_range##,,Q//r0c8URRU5$)zUReturn True if y is in the valid range of y_pred. Parameters ---------- y : ndarray )r+r3r4s r-in_y_pred_rangeBaseLoss.in_y_pred_ranger8r0cUc[R"U5nURS:Xa$URSS:XaUR S5nUR R UUUUUS9 U$)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,) 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@rArBrCrDs r-rI BaseLoss.lossss<  }}V,H   ! #(<()r@rArBrC gradient_outrD)r(rErNrFrGrHr! loss_gradient)r,r@rArBrCrOrDs r-rPBaseLoss.loss_gradientsL  #==0!}}^< ==7I7IJ  !==~~NL   ! #(<()r@rArBrOrD)r(rErFrGrHr!gradientr,r@rArBrOrDs r-rSBaseLoss.gradients>  ==8L   ! #(<()r@rArBrO hessian_outrD)r(rErFrGrHr!gradient_hessian)r,r@rArBrOrWrDs r-rXBaseLoss.gradient_hessianPsN  "!}}^<  mmN; !}}[9  -- 5K   ! #(<(%--a0K ##)'%# $ ((r0c N[R"URUUSSUS9US9$)aCompute 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(averagerI)r,r@rArBrDs r-__call__BaseLoss.__call__s:(zz II-"#  "  r0c[R"XSS9nS[R"UR5R-nUR R [R*:XaSnOKUR R(aUR R nOUR R U-nUR R[R:XaSnOKUR R(aUR RnOUR RU- nUcUcURRU5$URR[R"X5U55$)aCompute 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. rr\axis N) r(r]finforNepsr+lowr) low_inclusivehighhigh_inclusiver"clip)r,r@rBy_predrea_mina_maxs r-fit_intercept_onlyBaseLoss.fit_intercept_onlys(FB288FLL)---    # #w .E  ! ! / /((,,E((,,s2E    $ $ .E  ! ! 0 0((--E((--3E =U]99>>&) )99>>"''&"?@ @r0c.[R"U5$)aCalculate 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@rBs r-constant_to_optimal_zero!BaseLoss.constant_to_optimal_zeros&}}V$$r0FcXU[R[R4;a[SUS35eUR(aXR 4nOU4n[R "XBUS9nUR(a[R"SUS9nXV4$[R "XBUS9nXV4$)aInitialize 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.)rGrNorder)r>)rGrN) r(float32float64 ValueError is_multiclassr#emptyr'ones)r, n_samplesrNrwrGrShessians r-init_gradient_and_hessian"BaseLoss.init_gradient_and_hessians8 RZZ0 0"G9.    /ELE88%EB  ggD6G  hhUuEG  r0) r&r!r'r%r+r*r"r#r$NNNNNr>NNNr>Nr>N)__name__ __module__ __qualname____firstlineno____doc__differentiabler{r.r6r:rIrPrSrXr^rnrsr(ryr__static_attributes__r0r-rrMs:JNM 900 +b=&F /j@)D >(AT%*:<31!r0rc0^\rSrSrSrSU4SjjrSrU=r$)HalfSquaredErrori$aHalf 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. cV>[TU][5[5X#S9 USLUlg)Nr!r"r$r%)superr.r rr'r,rBr$r% __class__s r-r.HalfSquaredError.__init__6s0 $&\^  !. 5r0)r'rrrrrrr.r __classcell__rs@r-rr$s"66r0rc>^\rSrSrSrSrSU4SjjrSSjrSrU=r $) AbsoluteErrori=aAbsolute 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. Fcd>[TU][5[5X#S9 SUlUSLUlg)NrT)rr.rrr&r'rs r-r.AbsoluteError.__init__Qs8 !#,.R  # - 5r0cJUc[R"USS9$[XS5$)}Compute raw_prediction of an intercept-only model. This is the weighted median of the target, i.e. over the samples axis=0. rrb2)r(medianrrrs r-rn AbsoluteError.fit_intercept_onlyXs(  99V!, ,'rB Br0r&r'rr rrrrrrr.rnrrrs@r-rr=s "N6 C Cr0rc>^\rSrSrSrSrSU4SjjrSSjrSrU=r $) PinballLossida3Quantile 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). Fc >[US[RSSSS9 [TU][ [ U5S9[5UUS9 SUlUSLUl g) Nquantilerr>neither target_typemin_valmax_valinclude_boundaries)rrT) rnumbersRealrr.rfloatrr&r')r,rBrr$r%rs r-r.PinballLoss.__init__sc   (   x9  # - 5r0cUc-[R"USURR-SS9$[ XSURR-5$)rdrr)r( percentiler!rrrrs r-rnPinballLoss.fit_intercept_onlysM  ==tzz/B/B)BK K'sTZZ-@-@'@ r0r)N?NNrrrs@r-rrds:N6$  r0rc@^\rSrSrSrSrSU4SjjrSSjrSrU=r $) HuberLossiaHuber 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. Fc >[US[RSSSS9 X l[TU][ [U5S9[5UUS9 SUl S Ul g) Nrrr>rr)deltarTF) rrrrrr.rrrr&r')r,rBrrr$r%rs r-r.HuberLoss.__init__se    (  !  E%L1  # %r0c0Uc[R"USSS9nO [XS5nX- n[R"U5[R"UR R [R"U55-nU[R"XRS9-$)rrrrr[) r(rrsignminimumr!rabsr])r,r@rBrdiffterms r-rnHuberLoss.fit_intercept_onlysr  ]]62A6F)&DFwwt}rzz$***:*:BFF4LII 4???r0)r&r'r)Ng?rNNrrrs@r-rrs(BNLP&*@@r0rc:^\rSrSrSrSU4SjjrSSjrSrU=r$)HalfPoissonLossiaOHalf 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`. c>[TU][5[5X#S9 [ S[ R SS5Ulg)NrrTF)rr.r rrr(r)r*rs r-r.HalfPoissonLoss.__init__s: #%GI"   (2664?r0c0[X5U- nUbX2-nU$rrr,r@rBrs r-rs(HalfPoissonLoss.constant_to_optimal_zero s$V$v-  $  !D r0r*rr rrrrrr.rsrrrs@r-rrs(@ r0rc:^\rSrSrSrSU4SjjrSSjrSrU=r$) HalfGammaLossia&Half 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`. c>[TU][5[5X#S9 [ S[ R SS5Ulg)NrrF)rr.rrrr(r)r*rs r-r.HalfGammaLoss.__init__&s3 0wyRW'2665%@r0cH[R"U5*S- nUbX2-nU$r)r(logrs r-rs&HalfGammaLoss.constant_to_optimal_zero*s)v"  $  !D r0rrrrrs@r-rrs&Ar0rc:^\rSrSrSrSU4SjjrSSjrSrU=r$)HalfTweedieLossi1aHalf 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. c>[TU][[U5S9[ 5UUS9 UR R S::a1[[R*[RSS5Ul gUR R S:a"[S[RSS5Ul g[S[RSS5Ul gN)powerrrFr=T) rr.r rrr!rrr(r)r*r,rBrr$r%rs r-r.HalfTweedieLoss.__init__Ps #%,7  ::  q #+RVVGRVVUE#JD ZZ   !#+ArvvtU#CD #+Arvvue#DD r0cURRS:Xa[5RXS9$URRS:Xa[ 5RXS9$URRS:Xa[ 5RXS9$URRn[ R"[ R"US5SU- 5SU- - SU- - nUbXB-nU$)Nr)r@rBr>r=)r!rrrsrrr(maximum)r,r@rBprs r-rs(HalfTweedieLoss.constant_to_optimal_zero^s ::  q #%>>? ZZ   ""$==> ZZ   " ?;;<    A88BJJvq11q59QUCq1uMD(%Kr0rNg?NNrrrs@r-rr1s< Er0rc0^\rSrSrSrSU4SjjrSrU=r$)HalfTweedieLossIdentityisa"Half 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. c~>[TU][[U5S9[ 5UUS9 UR R S::a1[[R*[RSS5Ul O]UR R S:a"[S[RSS5Ul O![S[RSS5Ul UR R S:Xa1[[R*[RSS5Ul g[S[RSS5Ul gr) rr.r rrr!rrr(r)r*r+rs r-r. HalfTweedieLossIdentity.__init__s +%,?  ::  q #+RVVGRVVUE#JD ZZ   !#+ArvvtU#CD #+Arvvue#DD ::  q #+RVVGRVVUE#JD #+Arvvue#DD r0)r+r*rrrs@r-rrss6EEr0rc@^\rSrSrSrSU4SjjrSSjrSrSrU=r $) HalfBinomialLossia Half 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) cn>[TU][5[5SUUS9 [ SSSS5UlgNr=r!r"r#r$r%rr>T)rr.rrrr*rs r-r.HalfBinomialLoss.__init__s> $&   (1dD9r0cP[X5[SU- SU- 5-nUbX2-nU$rrrs r-rs)HalfBinomialLoss.constant_to_optimal_zeros3V$uQZV'DD  $  !D r0c4URS:Xa$URSS:XaURS5n[R"URSS4UR S9nUR RU5USS2S4'SUSS2S4- USS2S4'U$zPredict 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. r=r>rrMNrFrGrHr(r|rNr"inverser,rAprobas r- predict_probaHalfBinomialLoss.predict_proba   ! #(<(:r0rc\^\rSrSrSrSrS U4SjjrSrS SjrSr S Sjr S r U=r $) HalfMultinomialLossiaCategorical 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>` Tc>[TU][5[5UUUS9 [ S[ R SS5Ul[ SSSS5UlSUl SUl SUl g)NrrTFr>) rr.r rrr(r)r*r+class_indexing_offsets y_true_inty_true_one_hotr,rBr#r$r%rs r-r.HalfMultinomialLoss.__init__so ')!#   (2664?'1eU;'+#"r0cURRU5=(a, [R"UR [ 5U:H5$r2)r*r3r(allastypeintr4s r-r6#HalfMultinomialLoss.in_y_true_range.s6##,,Q/NBFF188C=A;M4NNr0c[R"URURS9n[R"UR5R n[ UR5H<n[R"X:HUSS9X5'[R"X5USU- 5X5'M> URRUSSS245RS5$)aCompute 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. rMrrar>N) r(zerosr#rNrdreranger]rjr"reshape)r,r@rBoutreks r-rn&HalfMultinomialLoss.fit_intercept_only7s&hht~~V\\:hhv||$((t~~&AZZ ]KCFWWSVS!c'2CF'yy~~c$'l+33B77r0c8URRU5$)zPredict 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,rAs r-r!HalfMultinomialLoss.predict_probaQsyy  00r0c  UcGUc-[R"U5n[R"U5nO0[R"U5nOUc[R"U5nURRUUUUUUS9 XE4$)aCompute 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@rArBrO proba_outrD)r(rEr!gradient_proba)r,r@rArBrOrrDs r-r"HalfMultinomialLoss.gradient_proba`sH   !}}^< MM.9 !}}Y7   l3I !!)'% " &&r0)rr+r*rrNNNrr) rrrrrr{r.r6rnrrrrrs@r-rrs=.`M#"O84 1&5'5'r0rc@^\rSrSrSrSU4SjjrSSjrSrSrU=r $) ExponentialLossiaExponential 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)) cn>[TU][5[5SUUS9 [ SSSS5Ulgr)rr.rrrr*rs r-r.ExponentialLoss.__init__s> #%   (1dD9r0cRS[R"USU- -5-nUbX2-nU$)Nr>)r(sqrtrs r-rs(ExponentialLoss.constant_to_optimal_zeros1BGGFa&j122  $  !D r0c4URS:Xa$URSS:XaURS5n[R"URSS4UR S9nUR RU5USS2S4'SUSS2S4- USS2S4'U$rrrs r-rExponentialLoss.predict_probarr0rrrrrs@r-rrs!F:r0r) squared_errorabsolute_error pinball_loss huber_loss poisson_loss gamma_loss tweedie_loss binomial_lossmultinomial_lossexponential_losscX\rSrSrSrS SjrS SjrS SjrS SjrSr g) ArrayAPILossMixiniaMixin 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. Nc\URXSS9n[[XSURS95$)a Compute 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@rArB)r\r$)rIrrr$)r,r@rArBrDloss_xps r-r^ArrayAPILossMixin.__call__s44)) XgIJJr0c$URUUUS9$)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_lossrJs r-rIArrayAPILossMixin.losss%:!!)'"  r0cLURUUUS9nURUUUS9nXx4$)aCompute 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@rArBrCrOrDrIrSs r-rPArrayAPILossMixin.loss_gradientAsMH!!)'"  )))'*  ~r0c$URUUUS9$)aCompute 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+)r2rTs r-rSArrayAPILossMixin.gradientqs%<%%)'&  r0rrrr) rrrrrr^rIrPrSrrr0r-r)r)sK " KF ! N.h " r0r)cHURUR:Xa/SQO/SQnURXS:*UURXS:*URU5URXS:*UR SU-5URXS:*USU- -U5555$)a6Numerically 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>r=g?r)rNrywherelog1pr)rAraw_prediction_expr$ constantss r- _log1pexpr?sj   2:: -   88A,&  l * HH' ( HHA,.s//0"l2"Q);%;;"   r0cF\rSrSrSrSSjrS SjrS SjrSrg) HalfBinomialLossArrayAPIizHA version of the HalfBinomialLoss that is compatible with the array API.NcURRU5nURUUUUS9nURUUUUS9n X4$N)r@rArBr=r$expr/r2 r,r@rArBrCrOrDr=rIrSs r-rP&HalfBinomialLossArrayAPI.loss_gradiente"WW[[8!!)'1 "  )))'1 *  ~r0cUcURRU5n[UUURS9nXQU-- nUbXc-nU$)N)rAr=r$)r$rEr?)r,r@rArBr=log1pexprIs r-r/&HalfBinomialLossArrayAPI._compute_losssV  %!%^!< )1ww  >11  $  !D r0cURnUcURU5nSU- nURX"RUR:XaSOS:SU- X-- SU-- XA- 5nUbXs-nU$)Nr>r7r9)r$rEr;rNry)r,r@rArBr=r$neg_raw_prediction_expgrads r-r2*HalfBinomialLossArrayAPI._compute_gradientsWW  %!#!7 !"%7!7xx %9%9RZZ%GcS Q&jF; ;)) +  '    $  !D r0rrNN rrrrrrPr/r2rrr0r-rArAs2R 8 . r0rAcH^\rSrSrSrSU4SjjrSSjrSSjrSrU=r $) HalfMultinomialLossArrayAPIi%aqA 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. cL>[TU]X#US9 SUlSUlSUlg)N)r#r$r%)rr.rrrrs r-r.$HalfMultinomialLossArrayAPI.__init__7s0 9FC '+##r0cURnURn[USUS9nURcUR XR US9UlUR c/URURSUS9UR-UlUR[U5URUR -5nXg- nUbX-nU$)Nr>)rbr$rNr%r)r%) r$r%rrasarrayint64rarangerGr#taker) r,r@rArBr$r% log_sum_exptrue_label_probsrIs r-r/)HalfMultinomialLossArrayAPI._compute_lossDs WW aB? ?? " jjxxjODO  & & . &,,q/& 9DNNJ  '77 > "DOOd6Q6Q$Q -  $  !D r0cRURnURnURcZURcUR XR US9Ul[ URURURS9Ul[U5nX`R-nUb XcSS2S4-nU$)NrW) num_classesrN) r$r%rrrXrYrr#rNr)r,r@rArBr$device_rNs r-r2-HalfMultinomialLossArrayAPI._compute_gradient\s WW++    &&"$**V88G*"T") NN$**#D  ~& ###  $ !T'* *D r0)rrrrr) rrrrrr.r/r2rrrs@r-rSrS%s&" #" 8 r0rScF\rSrSrSrSSjrS SjrS SjrSrg) HalfPoissonLossArrayAPIi}zGA version of the HalfPoissonLoss that is compatible with the array API.NcURRU5nURUUUUS9nURUUUUS9n X4$rCrDrFs r-rP%HalfPoissonLossArrayAPI.loss_gradientrHr0c^UcURRU5nXAU-- nUbXS-nU$rr$rE)r,r@rArBr=rIs r-r/%HalfPoissonLossArrayAPI._compute_losss=  %!%^!< !^$;;  $  !D r0cXUcURRU5nXA- nUbXS-nU$rrh)r,r@rArBr=rNs r-r2)HalfPoissonLossArrayAPI._compute_gradients8  %!%^!< !*  $  !D r0rrrPrQrr0r-rdrd}s2Q 8 $ r0rd)7rrnumpyr( 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_LOSSESr)r?rArSrdrr0r-rvse*    6& *4*T!T!n6x62$CH$CN=(=@I@I@XhDH>?h?D-Eh-E`DxDNk'(k'\HhHX&###%+' b b JHVA02BAHU"35HUp5/5r0