
    Pi0                        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#  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j.         ej.        gf e            g dej.         ej.        gf e            g dej.         ej.        gf e            g dej.         ej.        gf e            ddgej.         dd ej.        gf e            ddgej.         dd d ej.        gf ed          ddgej.         ej.        gf ed           ddgej.         ej.        gf ed!          ddgej.         dd ej.        gf ed          ddgej.         dd d ej.        gf ed"          ddgej.         dd d ej.        gf ed          ddgej.         ej.        gf ed           g d#ej.         ej.        gf ed!          ddgej.         dd ej.        gf ed          ddgej.         dd d ej.        gf ed"          ddgej.         dd d ej.        gf e            g d$ej.         d%dej.        gf e            g ej.         d%d&ej.        gfgZ/ 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
Z0 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	Z1ej+        ,                    d,e/e0z             d-             Z2ej+        ,                    d.e/e1z             d/             Z3ej+        ,                    d0g  e            d1d2d3d4df e            d1d2d5d1df ed+          d1d2dd+df ed          d1d2dddf ed          d2d1d1d6df ed+d"7          d1d2d8ddf ed+d"7          d1dd9ddf e            d9 ej4        d4          d4d ej4        d4          z  z
  dd4f e            d9 ej4        d4           ej4        d4          d+z   d+d+f ed"          d9 ej4        d4          d:ddf ed          d9d5dd ej4        d          z  z
  ddf ed          d9d5 ej4        d          d+z
  ddf ed"          d9d5d;ddf e            d ej4        d4           ej5        d4          d ej4        d4          z  z
  ddf e            d<d=d d d f e            d1d=d>d%d f e            d<d?d d d f e            d1d?d@d%d f e            d1dAdBd%d f e            d1dCdDdEdFf e            d<dCgdFgd"z  R  e            d1dGdHdEdIf e            d<dGgdIgd"z  R  e            d<dJdDdKdFf e            d1dJgdLgd"z  R  e            d<dBdBddMf e            d<dNdNddOf e            d1d>d d d f e            d<d>d>dd f e            d1dNd dPdOf e            d1dQd d d f e            d1d@d d d f e            d<d@d@dd f ed"R          d<g dS eg dS          dTz
  ddf ed"R          d1g dS eg dS          d+z
  ddf ed"R          d9g dS eg dS          dUz
  ddf ed"R          d9g dV eg dV          dWz
  ddfe(          dX             Z6ej+        ,                    de&          ej+        ,                    dYdZd[g          ej+        ,                    d\ej7        ej8        g          ej+        ,                    d]ej7        ej8        g          ej+        ,                    d^ddg          ej+        ,                    d_ddg          ej+        ,                    d`ddg          ej+        ,                    daddg          db                                                                                                 Z9ej+        ,                    de'e(          ej+        ,                    d^ddcg          dd                         Z:ej+        ,                    de'e(          ej+        ,                    d^ddcg          de                         Z;ej+        ,                    de'e(          ej+        ,                    d^dfdgg          dh                         Z<ej+        ,                    de'e(          di             Z=ej+        ,                    de'e(          ej+        ,                    d^ddcg          dj                         Z>ej+        ,                    de'e(          ej+        ,                    d^ddcg          dk                         Z?ej+        ,                    dlg dm          e#dn                         Z@ej+        ,                    de'e(          ej+        ,                    d^ddcg          do                         ZAej+        ,                    dp e            ejB        dqf e            ejC        dqf ed          dr dqf e            ejB        dsf e            ejB        dtf e            ejB        dtf e            ejB        dufg          dv             ZDdw ZEdx ZFdy ZGej+        ,                    dz ejH        g d{           ejH        g d|          f          ej+        ,                    d} ejH        g d~           ejH        g d          f          d                         ZIej+        ,                    de'e(          d             ZJej+        ,                    de&          ej+        ,                    d^ddcg          ej+        ,                    dej7        ej8        f          ej+        ,                    dd          d                                                 ZKej+        ,                    de&          ej+        ,                    ddejL        idejL         dfg          d                         ZMej+        ,                    deddieNdfedd ieOdfedd&ieOdfeddieNdfedd ieOdfedd&ieOdfg          d             ZPej+        ,                    de'e(          d             ZQej+        ,                    dg d          d             ZRd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_32bitc                 "    g | ]} |            S  r   ).0losss     q/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/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_namer4   4   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]   C   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(            (@)rB   	full_like)funcxepsh
f_minus_2h
f_minus_1h	f_plus_1h	f_plus_2hs           r    numerical_derivativerk   h   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.rA   r   r'   num
   N      ?r(   r\   r[   )rE   rB   tilelinspacer   rQ   rT   r_r=   rU   r>   in_y_true_rangeshaperN   rF   in_y_pred_rangerM   r   )r   rG   r\   r=   r>   ny_predr[   s           r    test_loss_boundaryr{   v   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"   )r6   r   皙?r7   r|   r7   皙      ?rA   )r}   r~   r   r|   r7   )r|   rq   ?g?)r6   r~   r   r6   )              ?r(   )r}   r~   r   rq   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)rv   rB   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)rx   rB   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      @r`      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@rG   )皙?rq   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.rr   V瞯<)relabsN)rB   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                 ~    |             } 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.
    r:   r5   rp   r;   r   rV   rW   rX   rY   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]   rK   rB   r   
empty_liker   r   r   r   rE   r   fit_intercept_onlyconstant_to_optimal_zeror0   r   r   )r   r   r   r   r   r   r   r   rV   r\   r[   lgrf   ps                  r    test_loss_dtyper   x  sG   $ 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999992%# 	 	 	A (1999992%#   DAq (1999992(1999992D.}^9===  %# !  DAq (1999992(1999992D~]SSSS6GGG!!}!MMMt_%% :.999t%&& 
7"")' # 
 
1 !,qDyyyyy6 ,qDyyyyyy6
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                            ||||
           t          ||           |                     ||||           | j                            ||||           t          ||           | j        	                    |||||           | j        	                    |||||           t          ||           t          ||           | 
                    |||||           | j        
                    |||||	           t          ||           t          ||	           dS )z:Test that Python and Cython functions return same results.   r5   r   r;   r   r   r'   r   rn   r\   r[   r   r   r\   r[   r   r   r\   r[   r   r   r   r\   r[   r   r   r   N)r]   rB   rt   rw   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   r5   r   r   r   r'   r   rn   r   r   r   r   r   r\   r[   r   r   r   axisdy=)rtolN)r]   rB   rt   rw   r   r   r   r   r   r   r   shares_memoryr0   rE   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"   onesrC   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.
    r7   r5   r8   r   r   )rw   r   r@   r   N)r]   rB   r   float64rC   rD   normalrK   r   r   r   rE   r   )r   r   r   rV   r\   r[   rZ   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   r5   r   r;   r   r'   Nrr   )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|   rA   rp   绽|=rp   )rw   r_   r   Nr'   r   r   rn   r   r   +=r   )atolr   )rE   rB   r   r-   rM   r   rN   r=   rT   r>   rU   clipinverserJ   rG   rK   rL   fullexprI   rt   rw   r   r   r   )	r   r   r[   re   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   r5   r8   r   r   r'   r   rn   r   c                 4                         |           S Nr   )r   rd   r   r   r\   s    r    	loss_funcz6test_gradients_hessians_numerically.<locals>.loss_func4  s'    99 +    r"   gư>)re   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   rd   rawkr   r[   r   r\   s     r    r  z6test_gradients_hessians_numerically.<locals>.loss_funcS  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_func_  s[    $))++AAAqD	}}!#&"/ %   !!Q$	 r"   )r]   rB   rt   rw   r   rE   rk   r   approx_hessianr   rG   )r   r   r   rV   r   rf   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_lossra   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   rd   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.
        rr   r\   )r   r   rd   r   r\   s    r    rc   ztest_derivatives.<locals>.func  s>     yy!  
 
)))889 	9r"   c                 2                         |           S )Nrr   r	  r  s    r    fprimez test_derivatives.<locals>.fprime  s    }}F1}===r"   c                 >                         |           d         S )Nrr   r'   )r   r  s    r    fprime2z!test_derivatives.<locals>.fprime2  s!    $$F1$EEaHHr"   r7   gHj>)x0r   r"  maxitertolr   r   r   rr   gƠ>)r   rB   r   r   ndarrayr	   ravelr   rM   r   r   )r   r#  r\   rc   r   r"  optimums   ` `    r    test_derivativesr*  p  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   rn   r   Nr:   r   r|   r(   r   c                     j         st          j        |           }n/t          j        t          j        | j        f                    } |          S )N)rw   r_   rw   r   )rE   rB   r   ascontiguousarraybroadcast_torG   )rd   r[   r   rV   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$  r7   )r%  optionsr   r   g-q=)r   gvIh%<=SLSQPr'   )r%  r3  methodconstraintsr  r  r   r&  )rE   rM   r   rB   rt   rJ   rK   r   rG   r   r   r   rb   rw   tupler   r   r   rd   r   r   zerosr   r   rs   r   )r   r   ar2  optgradrV   r\   s   ``    @@r    test_loss_intercept_onlyr=    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)rB   
percentile)rd   s    r    <lambda>rB    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.
    rE  r'   rq   r7   r@   r  N)rB   rC   rD   rE  getattrr   r   r   rM   r   r-   r   r   rQ   rT   fillr=   rU   r>   )r   rc   random_distr   rZ   y_trainbaseline_predictions          r     test_specific_fit_intercept_onlyrL    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'   r7   r@   r  r   Nrp   r/  )rB   rC   rD   r   randintrK   r   r   rw   r9  r   r   meanr   logrM   r   r   )rZ   rG   r   rJ  rK  r   r  s          r    (test_multinomial_loss_fit_intercept_onlyrQ    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`.
    r7   r:   r   r   rV   rY   r|   r(   rn   r   N)r   r]   rB   rt   r,   _test_cy_gradientr   r   )	r   rV   rG   r   r\   r[   r   r   r   s	            r    test_multinomial_cy_gradientrU  5  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   r@   g      Nrq   r'   rr   )rB   rC   rD   r   r   rN  rK   r   r   rF   r   r   )r   rZ   rV   binommultinomrJ  r[   raw_multinoms           r    "test_binomial_and_multinomial_lossrZ  S  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'   rz   )g      r9   r9   )r)   rA   rA   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'   )rB   rO  rP  r   r   raw_predzs      r    alt_lossz:test_binomial_vs_alternative_formulation.<locals>.alt_lossu  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 r]  )rB   r   r^  s      r    alt_gradientz>test_binomial_vs_alternative_formulation.<locals>.alt_gradienty  s/    EAIrQH---..r"   N)r   rK   r   r   r   )r\   rz   global_dtypera  rc  bin_lossdatums          r    (test_binomial_vs_alternative_formulationrg  d  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   r5   r8   r   r   r'   r   r   r4  r   )NNNr   r   )r]   r0   r   rw   rG   rB   r   r   r   r   r   r   )r   r   rV   r\   r[   r   r<  s          r    test_predict_probari    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  )rV   r   rj  )r'   rk  N)rB   r   init_gradient_and_hessianconstant_hessianrw   rE   rG   r   flagsc_contiguousf_contiguous)r   r   r   rj  rV   r   r   s          r    test_init_gradient_and_hessiansrs    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.matchrV   r:   Nr   )pytestraises
ValueError	TypeErrorrn  )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.ru  Nr   )rw  rx  )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   r5   r8   r;   r   rr   N)r]   pickledumpsloadsr   )r   rV   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(   rA   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%   rp   r;   rS  rr   r(   N)	r   r   r]   rM   r   r   r   r   r   )r   half_tweedie_loghalf_tweedie_identityrV   r\   r[   rz   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"   )r5   r8   r;   )Sr  numpyrB   rw  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   listvalues
ALL_LOSSESLOSS_INSTANCESr4   r]   rk   markparametrizer{   infY_COMMON_PARAMSY_TRUE_PARAMSY_PRED_PARAMSr   r   rP  log1pr   float32r   r   r   r   r   r   r   r  r*  r=  rO  medianrL  rQ  rU  rZ  r   rg  ri  rs  int64r}  rz  ry  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/ 'm# 7 7	 7 'm# 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--Y7 Y7 .- ,+ ,+ 54 @? ?> ;: -,Y7x 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"   