
    0Ph                        d dl Z d dlZd dlZd dlmZmZ d dlmZ d dlm	Z	m
Z
mZmZ d dlmZ d dlmZmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZ d dlm Z  d d	l!m"Z"m#Z# d d
l$m%Z%  e& ej'                              Z(d e(D             Z)e) ed           ed           ed           ed            ed           ed           ed           ed            ed           ed           ed          gz  Z)d Z*	 ddZ+d Z,ej-        .                    de)e*          d             Z/ e            g dej0         ej0        gf e            g dej0         ej0        gf e            g dej0         ej0        gf e            g dej0         ej0        gf e            ddgej0         d d!ej0        gf e            ddgej0         d d!d ej0        gf ed           ddgej0         ej0        gf ed           ddgej0         ej0        gf ed"          ddgej0         d d!ej0        gf ed          ddgej0         d d!d ej0        gf ed#          ddgej0         d d!d ej0        gf ed           ddgej0         ej0        gf ed           g d$ej0         ej0        gf ed"          ddgej0         d d!ej0        gf ed          ddgej0         d d!d ej0        gf ed#          ddgej0         d d!d ej0        gf e            g d%ej0         d&dej0        gf e            g ej0         d&d'ej0        gfgZ1 e            d gg f e            d gg f ed           g d(g f ed           d)d gg f ed"          d gg f ed           g d(g f ed           d)d gg f ed"          d gg f e            d dgg f e            g d*g fg
Z2 e            g d gf ed           g g d+f ed           g g d+f ed"          g d gf ed           g g d+f ed           g d+g f ed"          g d gf e            g d dgf e            dd,gd dgfg	Z3ej-        .                    d-e1e2z             d.             Z4ej-        .                    d/e1e3z             d0             Z5ej-        .                    d1g  e            d2d3d4d5df e            d2d3d6d2df ed,          d2d3dd,df ed          d2d3dddf ed          d3d2d2d7df ed,d#8          d2d3d9ddf ed,d#8          d2dd:ddf e            d: ej6        d5          d5d ej6        d5          z  z
  dd5f e            d: ej6        d5           ej6        d5          d,z   d,d,f ed#          d: ej6        d5          d;ddf ed          d:d6dd ej6        d          z  z
  ddf ed          d:d6 ej6        d          d,z
  ddf ed#          d:d6d<ddf e            d ej6        d5           ej7        d5          d ej6        d5          z  z
  ddf e            d=d>d d d f e            d2d>d?d&d f e            d=d@d d d f e            d2d@dAd&d f e            d2dBdCd&d f e            d2dDdEdFdGf e            d=dDgdGgd#z  R  e            d2dHdIdFdJf e            d=dHgdJgd#z  R  e            d=dKdEdLdGf e            d2dKgdMgd#z  R  e            d=dCdCddNf e            d=dOdOddPf e            d2d?d d d f e            d=d?d?dd f e            d2dOd dQdPf e            d2dRd d d f e            d2dAd d d f e            d=dAdAdd f ed#S          d=g dT eg dT          dUz
  ddf ed#S          d2g dT eg dT          d,z
  ddf ed#S          d:g dT eg dT          dVz
  ddf ed#S          d:g dW eg dW          dXz
  ddfe*          dY             Z8ej-        .                    de(          ej-        .                    dZd[d\g          ej-        .                    d]ej9        ej:        g          ej-        .                    d^ej9        ej:        g          ej-        .                    d_ddg          ej-        .                    d`ddg          ej-        .                    daddg          ej-        .                    dbddg          dc                                                                                                 Z;ej-        .                    de)e*          ej-        .                    d_dddg          de                         Z<ej-        .                    de)e*          ej-        .                    d_dddg          df                         Z=ej-        .                    de)e*          ej-        .                    d_dgdhg          di                         Z>ej-        .                    de)e*          dj             Z?ej-        .                    de)e*          ej-        .                    d_dddg          dk                         Z@ej-        .                    de)e*          ej-        .                    d_dddg          dl                         ZAej-        .                    dmg dn          e#do                         ZBej-        .                    de)e*          ej-        .                    d_dddg          dp                         ZCej-        .                    dq e            ejD        drf e            ejE        drf ed          ds drf e            ejD        dtf e            ejD        duf e            ejD        duf e            ejD        dvfg          dw             ZFdx ZGdy ZHdz ZIej-        .                    d{ ejJ        g d|           ejJ        g d}          f          ej-        .                    d~ ejJ        g d           ejJ        g d          f          d                         ZKej-        .                    de)e*          d             ZLej-        .                    de(          ej-        .                    d_dddg          ej-        .                    dej9        ej:        f          ej-        .                    dd          d                                                 ZMej-        .                    de(          ej-        .                    ddejN        idejN         dfg          d                         ZOej-        .                    deddiePdfedd ieQdfedd'ieQdfeddiePdfedd ieQdfedd'ieQdfg          d             ZRej-        .                    de)e*          d             ZSej-        .                    dg d          d             ZTdS )    N)assert_allcloseassert_array_equal)approx)LinearConstraintminimizeminimize_scalarnewton)	logsumexp)IdentityLink_inclusive_low_high)_LOSSESAbsoluteErrorBaseLossHalfBinomialLossHalfGammaLossHalfMultinomialLossHalfPoissonLossHalfSquaredErrorHalfTweedieLossHalfTweedieLossIdentity	HuberLossPinballLoss)assert_all_finite)create_memmap_backed_dataskip_if_32bit)_IS_WASMc                 "    g | ]} |            S  r   ).0losss     ]/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/_loss/tests/test_loss.py
<listcomp>r"   $   s    000T$$&&000    g      ?)quantileg      ?      power            @c                 r   t          | t                    r| }|j        j        }t          |t                    r|d|j        j         dz  }n[t          |t                    r|d|j         z  }n8t          |d          r(t          |j        d          r|d|j        j	         dz  }|S t          |           S )Nz
(quantile=)clossr'   z(power=)
isinstancer   	__class____name__r   r-   r$   r   hasattrr'   str)paramr    names      r!   loss_instance_namer5   5   s    %"" ~&dK(( 	27!47777DDi(( 	20000DDT7## 	2
G(D(D 	21dj.1111D5zzr#   d      *   c                    t           j                            |          }| j        rt          j        || j        f          }|                    |d         |d         || j        z            |j        dd<   t          j        |          	                    t                    | j        z  }n:t          | j        t                    rSt          | j                  \  }}	t          j        ||d         g          }t          j        |	|d         g          }	||	f}|                    |d         |d         |          }t          | j                  \  }}	t'          ||d                   }t)          |	|d                   }	|                    ||	|          }| j        j        dk    r| j        j        rd|dd|dz  <   | j        j        dk    r| j        j        rd|dd|dz  <   ||fS )z9Random generate y_true and raw_prediction in valid range.r   r(   )lowhighsizeNr@      )nprandomRandomStateis_multiclassempty	n_classesuniformflatarangeastypefloatr.   linkr   r   interval_y_predamaxamininterval_y_truemaxminr>   low_inclusiver?   high_inclusive)
r    	n_samplesy_bound	raw_boundseedrngraw_predictiony_truer>   r?   s
             r!   random_y_true_raw_predictionr^   D   s    )


%
%C .9dn"=>>!$!1T^+ "- "
 "
AAA
 9%%,,U33dnD di.. 	$+D,@AAIC'3	!-..C7D)A,/00DdI!9Q<i % 
 
 ((<==	T#wqz""4$$S$Y77#q((T-A-O(*+F&&yA~&'$))d.B.Q),-F1(a()>!!r#   c                     t          j        ||          } | |d|z  z
            } | ||z
            } | ||z             } | |d|z  z             }| d|z  z   d|z  z
  |z   d|z  z  S )z2Helper function for numerical (first) derivatives.)
fill_valuer)            (@)rC   	full_like)funcxepsh
f_minus_2h
f_minus_1h	f_plus_1h	f_plus_2hs           r!   numerical_derivativerl   i   s     	Q3'''Aa!a%iJa!eJQUIQQYIJY&Z7*DPSTTr#   r    )idsc                    | j         r0d}t          j        t          j        d|dz
  |          d          }n.t	          | j                  \  }}t          j        ||d          }| j        j        rt          j        || j        j        f         }| j        j	        rt          j        || j        j
        f         }|                     |          sJ |j        d         }t	          | j                  \  }}| j         rgt          j        ||f          }t          j        |||          |dddf<   dd|dddf         z
  z  |dddf<   dd|dddf         z
  z  |dddf<   nt          j        |||          }|                     |          sJ | j                            |          }|                     ||	           dS )
z4Test interval ranges of y_true and y_pred in losses.rB   r   r(   num
   N      ?r)   r]   r\   )rF   rC   tilelinspacer   rR   rU   r_r>   rV   r?   in_y_true_rangeshaperO   rG   in_y_pred_rangerN   r    )r    rH   r]   r>   r?   ny_predr\   s           r!   test_loss_boundaryr|   w   s     0	Q	A9EEEqII'(<==	TS$B/// ) 9vt3778* :vt3889'''''QA#D$899IC /1i.)){3!444qqq!ta&A,./qqq!ta&A,./qqq!tS$A...''''' Y^^F++NIIVNI;;;;;r#   )r7   r   皙?r8   r}   r8   皙      ?rB   )r~   r   r   r}   r8   )r}   rr   ?g?)r7   r   r   r7   )              ?r)   )r~   r   r   rr   z!loss, y_true_success, y_true_failc                     |D ],}|                      t          j        |g                    sJ -|D ],}|                      t          j        |g                    rJ -dS )z-Test boundaries of y_true for loss functions.N)rw   rC   array)r    y_true_successy_true_failys       r!   test_loss_boundary_y_truer      z    
  3 3##BHaSMM222222 7 7''!6666667 7r#   z!loss, y_pred_success, y_pred_failc                     |D ],}|                      t          j        |g                    sJ -|D ],}|                      t          j        |g                    rJ -dS )z-Test boundaries of y_pred for loss functions.N)ry   rC   r   )r    y_pred_successy_pred_failr   s       r!   test_loss_boundary_y_predr      r   r#   zDloss, y_true, raw_prediction, loss_true, gradient_true, hessian_truer   g      @ra      g      @g      п)r$   deltag      @       @g      ȿg      ?r   g@xg@xDg     @g     @@g     Bg     B@g     B%   ggT`G<g33333sBg33333sB@g)Pv.<g     B@g?gU`G<g0fՍ<gm@g       +g       gm@rH   )皙?rr   333333?r   r   )g     @r   _eG|>r   c                     | t          j        |g          t          j        |g                    }|                     t          j        |g          t          j        |g                    }|                     t          j        |g          t          j        |g                    \  }}	|                     t          j        |g          t          j        |g                    \  }
}|t          |dd          k    sJ |t          |dd          k    sJ |H|t          |dd          k    sJ |	t          |dd          k    sJ |
t          |dd          k    sJ ||t          |dd          k    sJ dS dS )z7Test losses, gradients and hessians at specific values.rs   V瞯<)relabsN)rC   r   gradientloss_gradientgradient_hessianr   )r    r]   r\   	loss_truegradient_truehessian_trueloss1grad1loss2grad2grad3hesss               r!   test_loss_on_specific_valuesr      s   x D&**28^DT;U;UVVVEMMx!!"(N;K2L2L   E %%x!!"(N;K2L2L &  LE5 ''x!!"(N;K2L2L (  KE4 F9%U;;;;;;;F9%U;;;;;;; }%UCCCCCCC}%UCCCCCCC}%UCCCCCCCvl5AAAAAAA  AAr#   readonly_memmapFTdtype_in	dtype_outsample_weightout1out2	n_threadsc                    t           r|rt          j        d            |             } d}t          | |ddd          \  }	}
|	                    |          }	|
                    |          }
|t          j        d	g|z  |
          }|t          j        |	|
          }|t          j        |
|
          }|r/t          |	          }	t          |
          }
|t          |          }| 	                    |	|
|||          }|||u snnJ | 
                    |	|
|||          }|||u snnJ |                     |	|
||||          \  }}|||u snnJ |||u snnJ || j        rt          j        |
|
          }|                     |	|
||||          \  }}|||u snnJ |||u snnJ  | |	|
|           |                     |	|           |                     |	|           t!          | d          r|                     |
           t!          | d          r3|                     |	|
||||          \  }}|||u snnJ |||u sndS J dS dS )a0  Test acceptance of dtypes, readonly and writeable arrays in loss functions.

    Check that loss accepts if all input arrays are either all float32 or all
    float64, and all output arrays are either all float32 or all float64.

    Also check that input arrays can be readonly, e.g. memory mapped.
    zmemmap not fully supported)reasonr;   r6   rq   r<   r    rW   rX   rY   rZ   Nr   dtype)r]   r\   r   loss_outr   T)r]   r\   r   gradient_outr   )r]   r\   r   r   r   r   )r]   r\   r   r   hessian_outr   r]   r\   r   r]   r   predict_proba)r\   gradient_proba)r]   r\   r   r   	proba_outr   )r   pytestxfailr^   rL   rC   r   
empty_liker   r    r   r   rF   r   fit_intercept_onlyconstant_to_optimal_zeror1   r   r   )r    r   r   r   r   r   r   r   rW   r]   r\   lgrg   ps                  r!   test_loss_dtyper   w  sb   $  :O :89999466DI9  FN ]]8$$F#**844N #!2(CCC}V9555}^9=== E*6222>BB$5mDDM		%# 	 	 	A (1999999%# 	 	 	A (1999999%#   DAq (1999999(1999999D.}^9===  %# !  DAq (1999999(1999999D~]SSSS6GGG!!}!MMMt_%% :.999t%&& 
7"")' # 
 
1 !,qDyyyyyy ,qDyyyyyyy
7 
7 yr#   rangec                    t          | dddd          \  }}|dk    r-t          j        d|j        d         |j        d         	          }t          j        |          }t          j        |          }t          j        |          }t          j        |          }t          j        |          }t          j        |          }	|                     ||||
           | j                            ||||
          f t          ||           |                     ||||           | j                            ||||           t          ||           | j        	                    |||||           | j        	                    |||||           t          ||           t          ||           | 
                    |||||           | j        
                    |||||	           t          ||           t          ||	           dS )z:Test that Python and Cython functions return same results.   r6   r   r<   r   r   r(   r   ro   r]   r\   r   r   r]   r\   r   r   r]   r\   r   r   r   r]   r\   r   r   r   N)r^   rC   ru   rx   r   r    r-   r   r   r   r   )
r    r   r]   r\   out_l1out_l2out_g1out_g2out_h1out_h2s
             r!   test_loss_same_as_C_functionsr     s    :  FN Av|AFLOLLL]6""F]6""F]>**F]>**F]>**F]>**FII%#	     	JOO%#	      FF###MM%#	     	J%#	     FF###J%#     	J%#     FF###FF###%#     	J%#      FF###FF#####r#   c                    t          | ddd|          \  }}|dk    r-t          j        d|j        d         |j        d                   }t          j        |          }t          j        |          }t          j        |          }t          j        |          }t          j        |          }	t          j        |          }
|                     ||||	          }|                     ||||
          }|                     |||||          \  }}|                     ||||	|
          \  }}t          ||           t          ||           t          j        ||          sJ t          ||           t          j        ||          sJ t          ||           t          ||           t          ||           t          j        ||          sJ t          ||           t          j        ||          sJ t          ||	           t          j        ||	          sJ t          | d          r| j        sJ t          j        |          }t          j        |          }|                     |||||          \  }}t          ||           t          ||           t          ||           t          t          j        |d          dd           dS dS )zTest that loss and gradient are the same across different functions.

    Also test that output arguments contain correct results.
    r   r6   r   r   r   r(   r   ro   r   r   r   r   r   r]   r\   r   r   r   axisdy=)rtolN)r^   rC   ru   rx   r   r    r   r   r   r   r   shares_memoryr1   rF   r   sum)r    r   global_random_seedr]   r\   r   r   r   r   out_g3out_h3l1g1l2g2g3h3out_g4	out_probag4probas                        r!    test_loss_gradients_are_the_samer   .  s/    :  FN Av|AFLOLLL]6""F]6""F]>**F]>**F]>**F]>**F	%#	 
 
 
B 
%#	 
 
 
B %#    FB ""%# #  FB Br6"""B'''''r6"""B'''''BBr6"""B'''''r6"""B'''''r6"""B'''''t%&& >!!!!~..M.11	'')' ( 
 
	E 	F###By)))u1---qu======> >r#   onesrD   c           	         d}t          | |dd|          \  }}|dk    r!t          j        |t          j                  }nRt          j                            |          }|                    |                              t          j                  }t          | 	                    |||          || 	                    ||d	          z             | 
                    ||d	          \  }}| 
                    |||          \  }	}
t          ||z  |	           | j        st          ||z  |
           nt          ||d	d	d	f         z  |
           |                     ||d	          \  }}|                     |||          \  }
}| j        s(t          ||z  |
           t          ||z  |           d	S t          ||d	d	d	f         z  |
           t          ||d	d	d	f         z  |           d	S )
zTest sample weights in loss, gradients and hessians.

    Make sure that passing sample weights to loss, gradient and hessian
    computation methods is equivalent to multiplying by the weights.
    r8   r6   r9   r   r   )rx   r   rA   r   N)r^   rC   r   float64rD   rE   normalrL   r   r    r   rF   r   )r    r   r   rW   r]   r\   r[   lossesr   	losses_swgradient_swhessian
hessian_sws                r!   test_sample_weight_multipliesr     st    I9  FN irzBBBi##$677

	
2299"*EE		)' 	 	
 	

 	
)))  
 
	
   ))% *  FH
 "//%# 0  I{
 F]*I666 H=0+>>>>=D#99;GGG--% .  Hg
 #33%# 4  K
  F=0+>>>-/<<<<<=D#99;GGG-4"88*EEEEEr#   c                 6   t          | dddd          \  }}|j        dk    r|dddf         }t          |                     ||          |                     ||                     t          |                     ||          |                     ||                     t          |                     ||          |                     ||                     t          |                     ||          |                     ||                     dS dS )	z5Test that reshaped raw_prediction gives same results.r   r6   r   r<   r   r(   Nrs   )r^   ndimr   r    r   r   r   )r    r]   r\   raw_prediction_2ds       r!   test_graceful_squeezingr     sW    :  FN a*111d73IIV4EIFFIIVNICC	
 	
 	
 	f=NOOf^LL	
 	
 	
 	MM8IMJJMMMGG	
 	
 	
 	!!@Q!RR!!!OO	
 	
 	
 	
 	
  r#   c                 `   | j         st          j        g d          }t          | j        t
                    rRd}| j        j        }| j        j        s||z   }| j        j	        }| j        j
        s||z
  }t          j        |||          }| j                            |          }nt          j        | j                                      t                     }t          j        | j        | j        ft          j        d           t                     }t          j        d          |j        dd| j        dz   <   |dk    r-t          j        d|j        d         |j        d         	          }|                     |||
          }|                     ||          }t1          || dd           dS )z~Test value of perfect predictions.

    Loss of y_pred = y_true plus constant_to_optimal_zero should sums up to
    zero.
    )r   r   r   r}   rB   rq   绽|=rq   )rx   r`   r   Nr(   r   r   ro   r   r   +=r   )atolr   )rF   rC   r   r.   rN   r   rO   r>   rU   r?   rV   clipinverserK   rH   rL   rM   fullexprJ   ru   rx   r    r   r   )	r    r   r\   rf   r>   r?   r]   
loss_valueconstant_terms	            r!   test_loss_of_perfect_predictionr    s     @"<"<"<==di.. 	@C&*C'5  Ci',D'6 "czW^S$??N"">22 4>**11%88 >4>2r

{
 
 

 68VBZZ11t~112Av|AFLOLLL%#   J
 11] 2  M
 JUGGGGGGr#   c                 @   
 d}t           |dd|          \  dk    r-t          j        dj        d         j        d                                        	          \  }}|j        j        k    sJ |j        j        k    sJ  j        sc fd
}t          |d          }t          ||dd            fd}t          |d          }	 j        rdS t          ||	dd           dS t           j
                  D ]

 fd}t          |dd
f         d          }t          |dd
f         |dd           
 fd}t          |dd
f         d          }	 j        rqt          |dd
f         |	dd           dS )zTest gradients and hessians with numerical derivatives.

    Gradient should equal the numerical derivatives of the loss function.
    Hessians should equal the numerical derivatives of gradients.
    r   r6   r9   r   r   r(   r   ro   r   c                 4                         |           S Nr   )r    re   r    r   r]   s    r!   	loss_funcz6test_gradients_hessians_numerically.<locals>.loss_func6  s'    99 +    r#   gư>)rf   h㈵>r   r   r   c                 4                         |           S r  r   r  s    r!   	grad_funcz6test_gradients_hessians_numerically.<locals>.grad_func@  s'    == + !   r#   c                 n                                     }| |d d f<                       |          S r  )copyr    re   rawkr    r\   r   r]   s     r!   r	  z6test_gradients_hessians_numerically.<locals>.loss_funcU  sI    $))++AAAqD	yy!#&"/ !   r#   Ngh㈵>c                                                      }| |d d f<                       |          d d f         S r  )r  r   r  s     r!   r  z6test_gradients_hessians_numerically.<locals>.grad_funca  s[    $))++AAAqD	}}!#&"/ %   !!Q$	 r#   )r^   rC   ru   rx   r   rF   rl   r   approx_hessianr   rH   )r    r   r   rW   r   rg   r	  	g_numericr  	h_numericr  r\   r]   s   ``        @@@r!   #test_gradients_hessians_numericallyr    s    I9  FN Av|AFLOLLL  %# !  DAq 7n*****7n***** ;K	 	 	 	 	 	 	 )NMMM	94e<<<<	 	 	 	 	 	 	 )NMMM	 	ADAyt%@@@@@@ t~&& 	K 	KA         -Yqqq!t8LRVWWWIAaaadGYTFFFF         -Yqqq!t8LRVWWWI" K!!!Q$EJJJJJ9	K 	Kr#   zloss, x0, y_true)	)squared_errorg       r<   )r  g     @]@g?)r  r   r   )binomial_lossr   r}   )r  ir   )r     r   )poisson_lossrb   r   )r  r   r   )r  g      6g      $@c                     t                    d           t          j        gt          j                  t          j        |gt          j                  }dt          j        dt          j        f fd}dt          j        dt          j        f fd}dt          j        dt          j        f fd}t          ||||d	d
          }                                |                                }t           j        	                    |                     t           ||          dd           t           
                    |          dd           dS )ac  Test that gradients are zero at the minimum of the loss.

    We check this on a single value/sample using Halley's method with the
    first and second order derivatives computed by the Loss instance.
    Note that methods of Loss instances operate on arrays while the newton
    root finder expects a scalar or a one-element array for this purpose.
    Nr   r   re   returnc                 `                         |                                         z   S )zCompute loss plus constant term.

        The constant term is such that the minimum function value is zero,
        which is required by the Newton method.
        rs   r]   )r    r   re   r    r]   s    r!   rd   ztest_derivatives.<locals>.func  s>     yy!  
 
)))889 	9r#   c                 2                         |           S )Nrs   r  r"  s    r!   fprimez test_derivatives.<locals>.fprime  s    }}F1}===r#   c                 >                         |           d         S )Nrs   r(   )r   r"  s    r!   fprime2z!test_derivatives.<locals>.fprime2  s!    $$F1$EEaHHr#   r8   gHj>)x0r$  r&  maxitertolr   r   r   rs   gƠ>)r   rC   r   r   ndarrayr	   ravelr   rN   r   r   )r    r'  r]   rd   r$  r&  optimums   ` `    r!   test_derivativesr.  r  s   4 4=t,,,DXvhbj111F	2$bj	)	)	)B9
 9rz 9 9 9 9 9 9 9>"* > > > > > > > >I2: I"* I I I I I I I   G \\^^FmmooGDI%%g..777DDMM151111DMMMHH!RVWWWWWWr#   c                     d j         s0 j                            t          j        dd                    nAt          j                                      t          j                   j        z  dddd<   dk    rt          j        d	d
           	                              } fd} j         st          |dddi          }                     t          j        |                    }|j        t                      k    sJ |j        j        k    sJ t!          |           |t#          |j        d          k     |                                t#          dd          k     dS t)          |t          j         j                  dddidt-          t          j        d j        f          dd                    }                     t          j        |df                    }|j        j        k    sJ t!          |           t3          ||j        dd           t3          |                    d          dd           dS )zzTest that fit_intercept_only returns the argmin of the loss.

    Also test that the gradient is zero at the minimum.
    2   r   ro   r   Nr;   r   r}   r)   r   c                     j         st          j        |           }n/t          j        t          j        | j        f                    } |          S )N)rx   r`   rx   r   )rF   rC   r   ascontiguousarraybroadcast_torH   )re   r\   r    rW   r   r]   s     r!   funz%test_loss_intercept_only.<locals>.fun  ss    ! 	WI1EEENN1)T^)DEEE N t)'
 
 
 	
r#   gHz>r(  r8   )r)  optionsr   r   g-q=)r   gvIh%<=SLSQPr(   )r)  r7  methodconstraintsr
  r  r   r*  )rF   rN   r   rC   ru   rK   rL   r   rH   r   r   r   rc   rx   tupler   r   r   re   r   r   zerosr   r   rt   r   )r    r   ar6  optgradrW   r]   s   ``    @@r!   test_loss_intercept_onlyrA    s    I ""2;r1)#D#D#DEE9%%,,RZ884>IsssC	:::v]KKA
 
 
 
 
 
 
 
  9cti5EFFF}}<22'  
 

 w%''!!!!w&,&&&&!	VCEt$$$$$

fQE******* Hdn&&$(!T^1D)E)Eq!LL
 
 
 }}71y!n55'  
 

 w&,&&&&!35t%8888a((!%888888r#   zloss, func, random_distr   c                 .    t          j        | d          S )N   )q)rC   
percentile)re   s    r!   <lambda>rF    s    r}Q"/E/E/E r#   poissonexponentialbinomialc                    t           j                            |          }|dk    r|                    ddd          }n t	          ||          d          }|                     |          }t          |           |t          | j                             ||                              k    sJ | j        	                    |          t           ||                    k    sJ t          | t                    r(t          | j        	                    |          |           | j        j        rD|                    | j        j                   |                     |          }t          |           | j        j        rF|                    | j        j                   |                     |          }t          |           dS dS )zTest that fit_intercept_only returns the correct functional.

    We test the functional for specific, meaningful distributions, e.g.
    squared error estimates the expectation of a probability distribution.
    rI  r(   rr   r8   rA   r!  N)rC   rD   rE   rI  getattrr   r   r   rN   r   r.   r   r   rR   rU   fillr>   rV   r?   )r    rd   random_distr   r[   y_trainbaseline_predictions          r!    test_specific_fit_intercept_onlyrP    s   $ )

 2
3
3Cj  ,,q#C,00+'#{++555111AA )***&W)F)F"G"GGGGG9011VDDMM5J5JJJJJ$%% U	))*=>>@STTT ) /T)-..."55W5EE-...* /T).///"55W5EE-...../ /r#   c            	         t           j                            d          } d}t          |          }|                     d|dz   d                              t           j                  }|                    |          }|j        |fk    sJ t          j	        ||j
                  }t          |          D ]}||k                                    ||<   t          |t          j        |          t          j        t          j        |                    z
             t          |d	d	d	f         |j                            |d	d	d	f                              t          j	        d
          t          j        d
          fD ]X}|                    t           j                  }|                    |          }|j
        |j
        k    sJ t#          |           Yd	S )zATest that fit_intercept_only returns the mean functional for CCE.r   r   r   r(   r8   rA   r!  r   Nrq   r3  )rC   rD   rE   r   randintrL   r   r   rx   r=  r   r   meanr   logrN   r   r   )r[   rH   r    rN  rO  r   r  s          r!   (test_multinomial_loss_fit_intercept_onlyrU     s   
)


"
"CI333D kk!Y]k55<<RZHHG111AA$4444
'-000A9 % %1""$$!'RWRVAYY5G5G)GHHH'aaa0$)..472L2LMMMH2&&&b(9(9(9: / /..,,"55W5EE"(GM9999-....	/ /r#   c                    d}d}t          |          }t          |||           \  }}t          j        dd|          }|j                            |||          }|                    |||          }t          ||           d	S )
a  Test that Multinomial cy_gradient gives the same result as gradient.

    CyHalfMultinomialLoss does not inherit from CyLossFunction and has a different API.
    As a consequence, the functions like `loss` and `gradient` do not rely on `cy_loss`
    and `cy_gradient`.
    r8   r;   r   r    rW   rZ   r}   r)   ro   r   N)r   r^   rC   ru   r-   _test_cy_gradientr   r   )	r   rW   rH   r    r]   r\   r   r   r   s	            r!   test_multinomial_cy_gradientrY  7  s     II333D9  FN
 KQI666MJ((%# )  E
 MM%#   E
 E5!!!!!r#   c                    t           j                            |           }d}t                      }t	          d          }|                    dd|                              t           j                  }|                    |          }t          j	        |df          }d|z  |dddf<   d|z  |ddd	f<   t          |                    ||
          |                    ||
                     dS )zKTest that multinomial loss with n_classes = 2 is the same as binomial loss.r   r)   r   r   rA   g      Nrr   r(   rs   )rC   rD   rE   r   r   rR  rL   r   r   rG   r   r    )r   r[   rW   binommultinomrN  r\   raw_multinoms           r!   "test_binomial_and_multinomial_lossr^  U  s    
)

 2
3
3CIE"Q///Hkk!QYk//66rzBBGZZYZ//N8YN++L.LA~-LA

'.
AAW\BB    r#   r]   )r   r   r   )r   r(   r(   r{   )g      r:   r:   )r*   rB   rB   c                     d }d }t                      }|                     |          } |                    |          }| |f} || t           ||           k    sJ t           |j        |  ||            dS )a  Test that both formulations of the binomial deviance agree.

    Often, the binomial deviance or log loss is written in terms of a variable
    z in {-1, +1}, but we use y in {0, 1}, hence z = 2 * y - 1.
    ESL II Eq. (10.18):

        -loglike(z, f) = log(1 + exp(-2 * z * f))

    Note:
        - ESL 2*f = raw_prediction, hence the factor 2 of ESL disappears.
        - Deviance = -2*loglike + .., but HalfBinomialLoss is half of the
          deviance, hence the factor of 2 cancels in the comparison.
    c           	          d| z  dz
  }t          j        t          j        dt          j        | |z            z                       S Nr)   r(   )rC   rS  rT  r  r   raw_predzs      r!   alt_lossz:test_binomial_vs_alternative_formulation.<locals>.alt_lossw  s>    EAIwrva"&!h"7"7788999r#   c                 N    d| z  dz
  }| dt          j        ||z            z   z  S ra  )rC   r  rb  s      r!   alt_gradientz>test_binomial_vs_alternative_formulation.<locals>.alt_gradient{  s/    EAIrQH---..r#   N)r   rL   r   r   r   )r]   r{   global_dtypere  rg  bin_lossdatums          r!   (test_binomial_vs_alternative_formulationrk  f  s    ": : :/ / /
  !!H]]<((F]]<((FVE8Uvhh&6777777%H%u-||U/CDDDDDr#   c           
         d}t          | |dd|          \  }}t          | d          rT|                     |          }|j        || j        fk    sJ t          j        |d          t          dd	          k    sJ t          | d
          rddt          j        |          ft          j        |          dft          j        |          t          j        |          ffD ]\  }}| 	                    ||d||          \  }}|j        || j        fk    sJ t          j        |d          t          dd	          k    sJ t          ||                     ||dd                     dS dS )z<Test that predict_proba and gradient_proba work as expected.r   r6   r9   r   r   r(   r   r   r8  r   )NNNr   r   )r^   r1   r   rx   rH   rC   r   r   r   r   r   r   )r    r   rW   r]   r\   r   r@  s          r!   test_predict_probarm    s    I9  FN t_%% ="">22{y$.99999ve!$$$qe(<(<(<<<<<t%&& 2=001]>**D1]>**BM.,I,IJ	
 	 	KD% ---"! .  KD% ;9dn"=====6%a(((F1%,@,@,@@@@@!#1"&!%	      ! 	 	r#   r   order)CFc                    d}|dk    rt          j        |          } | |          } |                     |||          \  }}| j        r|j        |fk    sJ |j        dk    sJ nL| j        r)|j        || j        fk    sJ |j        || j        fk    sJ n|j        |fk    sJ |j        |fk    sJ |j        |k    sJ |j        |k    sJ |dk    r|j        j	        sJ |j        j	        sJ dS |j        j
        sJ |j        j
        sJ dS )zTest that init_gradient_and_hessian works as expected.

    passing sample_weight to a loss correctly influences the constant_hessian
    attribute, and consequently the shape of the hessian array.
    r;   r   r  )rW   r   rn  )r(   ro  N)rC   r   init_gradient_and_hessianconstant_hessianrx   rF   rH   r   flagsc_contiguousf_contiguous)r    r   r   rn  rW   r   r   s          r!   test_init_gradient_and_hessiansrw    s    I	**4m,,,D66 7  Hg
  -~)----}$$$$$		 -~)T^!<<<<<}DN ;;;;;;},,,,},,,,>U""""=E!!!!||~****}))))))~****}))))))r#   zparams, err_msgz+Valid options for 'dtype' are .* Got dtype=z	 instead.c                      |             } t          j        t          t          f|          5   | j        dddi|\  }}ddd           dS # 1 swxY w Y   dS )zDTest that init_gradient_and_hessian raises errors for invalid input.matchrW   r;   Nr   )r   raises
ValueError	TypeErrorrr  )r    paramserr_msgr   r   s        r!   %test_init_gradient_and_hessian_raisesr    s     466D	
I.g	>	>	> R R:D:QQQQ&QQ'R R R R R R R R R R R R R R R R R Rs   AAAzloss, params, err_type, err_msgr$   z4quantile must be an instance of float, not NoneType.zquantile == 0, must be > 0.zquantile == 1.1, must be < 1.c                 t    t          j        ||          5   | di | ddd           dS # 1 swxY w Y   dS )z/Test that loss raises errors for invalid input.ry  Nr   )r   r{  )r    r~  err_typer  s       r!   #test_loss_init_parameter_validationr    s    B 
xw	/	/	/  v                 s   	-11c                     d}t          | |ddd          \  }}t          j        |           }t          j        |          } | ||          t	           |||                    k    sJ dS )z Test that losses can be pickled.r   r6   r9   r<   r   rs   N)r^   pickledumpsloadsr   )r    rW   r]   r\   pickled_lossunpickled_losss         r!   test_loss_pickler    s     I9  FN <%%L\,//N4vn===f^DDDB B      r#   r   )r%   r   r(   r   r)   rB   c                 B   t          |           }t          |           }d}t          ||d          \  }}|j                            |          }|                    ||          |                    |          z   }|                    ||          |                    |          z   }t          ||           |                    ||          \  }	}
|                    ||          \  }}t          |	||z             t          |
||z  |dz  |z  z              dS )zCTest for identical losses when only the link function is different.r&   rq   r<   rW  rs   r)   N)	r   r   r^   rN   r   r    r   r   r   )r   half_tweedie_loghalf_tweedie_identityrW   r]   r\   r{   loss_logloss_identitygradient_loghessian_loggradient_identityhessian_identitys                r!   %test_tweedie_log_identity_consistencyr  &  s    'Q///3!<<<I9  FN "**>::F  $$n %  11&99:H *..f /  66v>>?M Hm,,, !1 A An !B ! !L+ +@*P*Pf +Q + +'' L&+<"<===V//&!)>N2NN    r#   )r6   r9   r<   )Ur  numpyrC   r   numpy.testingr   r   r   scipy.optimizer   r   r   r	   scipy.specialr
   sklearn._loss.linkr   r   sklearn._loss.lossr   r   r   r   r   r   r   r   r   r   r   r   sklearn.utilsr   sklearn.utils._testingr   r   sklearn.utils.fixesr   listvalues
ALL_LOSSESLOSS_INSTANCESr5   r^   rl   markparametrizer|   infY_COMMON_PARAMSY_TRUE_PARAMSY_PRED_PARAMSr   r   rT  log1pr   float32r   r   r   r   r   r   r  r  r.  rA  rS  medianrP  rU  rY  r^  r   rk  rm  rw  int64r  r}  r|  r  r  r  r   r#   r!   <module>r     s         = = = = = = = =                  $ # # # # # @ @ @ @ @ @ @ @                            , + + + + + K K K K K K K K ( ( ( ( ( (T.'.""##
00Z000 KItO$O!O!O!O#!$$$!$$$!$$$#&&&     CE"" "" "" ""JU U U 5GHH <  < IH <L ,,,w.?@]__)))RVGRV+<=[]]'''26'26):;Y[[%%%'89_c
bfWb$$?@]__sCjBF7Ba"@A_2c
bfWbf,=>_1SzRVGRV+<=_3#srvgr4-HI_1SzRVGRq"&+IJ_1SzRVGRq"&+IJ2&&&c
bfWbf4EF1%%%'>'>'>"&"&@QR3'''#srvgr45PQ1%%%SzRVGRq"&3QR1%%%SzRVGRq"&3QRBF7B26*BCB"&"c26 :;'2 _R Y[[1#r_24_1ay"-_3!b)2&&&<1%%%ay"53'''!b1!Q$MMM2. _QC _2MMM2_1r===1_3aS)2&&&MMM:1%%%}}}b93'''aS1aV$S#JA/ '=)H 7 7 7 '=)H 7 7 7 Js				S#q!Q/s	#sCd3s 
c	"	"	"Cad;s 
d	#	#	#S#~xN	s
 
d	#	#	#S#xEs 
Cq	)	)	)3_dDQs 
Cq	)	)	)3ZtLs 
		CAFBF1II,=uaHs 
#vrvayy&"&))e*;YNs 
q	!	!	!3q		3DdDQs 
!	 q	)	)	)3QVRVAYY5FdSs 
!	 q	)	)	)3VRVAYY5FdSs $#!,,,)	
s, BF1IIBHQKK$**	
+sr 
			S%Aq1sst 
			S%r15usv 
			S$1a0wsx 
			S$R3ysz 
			S%r15{s| 
			S%Y8MN}s~ 
			S%F+@*AA*EFFs@ 
			S%y:OPAsB 
			S%F+@*AA*EFFCsD 
			S$I7LMEsF 
			S$E*?)@1)DEEGsH 
			S$a1FGIsJ 
			S%3JKKsL 
			S$1a0MsN 
			S$a3OsR $#	
Qs` 
			S%Aq1asb 
			S#q!Q/csd 
			S#sAq1esh  !,,,OOIooo&&,	
gsx  !,,,OOIooo&&,	
wsH  !,,,OOIooo&&,	
GsX  !,,,NNInnn%%.	
Wsh 	m  w wpB Bqw wpB6 ,,*UDM::bj"*%=>>rz2:&>??4)44$++$++q!f--\7 \7 .- ,+ ,+ 54 @? ?> ;: -,\7~ 5GHH4/::K$ K$ ;: IHK$\ 5GHH4/::L> L> ;: IHL>^ 5GHH68*<==BF BF >= IHBFJ 5GHH
 
 IH
< 5GHH4/::-H -H ;: IH-H` 5GHH4/::VK VK ;: IHVKr    " +X +X # $+X\ 5GHH4/::>9 >9 ;: IH>9B 				RWh/	")X.	d	#	#	#%E%ExP			BGY/	"'=1			BG]3				RWj1 / / />/ / /." " "<  " HBH[[[$9$9828KKK;P;P#QRRHBH^^^$<$<hbh{{{>S>S#TUUE E VU SRED 5GHH( ( IH(V ,,4/::2:rz":;;*--!* !* .- <; ;: -,!*H ,, bhM"(MMM	
 R R  -,R % B		
 O)		
 
z3'5TUB		
 O)		
 
Z%z3RS5 > ? > 5GHH  IH" 55566) ) 76) ) )r#   