
    _nd                        d dl Z d dlZd dlmZmZ d dl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 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          g
z  Z&d Z'	 drd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            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 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	Z/ 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	Z0ej*        +                    d+e.e/z             d,             Z1ej*        +                    d-e.e0z             d.             Z2ej*        +                    d/ e            d0d1d2f e            d0d1d3f ed*          d0d1df ed          d0d1df ed          d1d0d0f e            d4 ej3        d3          d3d ej3        d3          z  z
  f e            d4 ej3        d3           ej3        d3          d*z   f ed!          d4 ej3        d3          d5f ed          d4d6dd ej3        d          z  z
  f ed          d4d6 ej3        d          d*z
  f ed!          d4d6d7f e            d ej3        d3           ej3        d8          d ej3        d3          z  z
  f ed!9          d:g d; eg d;          d<z
  f ed!9          d0g d; eg d;          d*z
  f ed!9          d4g d; eg d;          d=z
  fge'          d>             Z4ej*        +                    de%          ej*        +                    d?d@dAg          ej*        +                    dBej5        ej6        g          ej*        +                    dCej5        ej6        g          ej*        +                    dDddg          ej*        +                    dEddg          ej*        +                    dFddg          ej*        +                    dGddg          dH                                                                                                 Z7ej*        +                    de&e'          ej*        +                    dDddIg          dJ                         Z8ej*        +                    de&e'          ej*        +                    dDddIg          dK                         Z9ej*        +                    de&e'          ej*        +                    dDdLdMg          dN                         Z:ej*        +                    de&e'          dO             Z;ej*        +                    de&e'          ej*        +                    dDddIg          dP                         Z<ej*        +                    de&e'          ej*        +                    dDddIg          dQ                         Z=ej*        +                    dRg dS          e"dT                         Z>ej*        +                    de&e'          ej*        +                    dDddIg          dU                         Z?ej*        +                    dV e            ej@        dWf e            ejA        dWf ed          dX dWf e            ej@        dYf e            ej@        dZf e            ej@        dZf e            ej@        d[fg          d\             ZBd] ZCd^ ZDej*        +                    de&e'          d_             ZEej*        +                    de%          ej*        +                    dDddIg          ej*        +                    d`ej5        ej6        f          ej*        +                    dadb          dc                                                 ZFej*        +                    de%          ej*        +                    ddd`ejG        ideejG         dffg          dg                         ZHej*        +                    dhedidieIdjfedid ieJdkfedid%ieJdlfg          dm             ZKej*        +                    de&e'          dn             ZLej*        +                    dog dp          dq             ZMdS )s    N)assert_allcloseassert_array_equal)approx)minimizeminimize_scalarnewtonLinearConstraint)	logsumexp)_inclusive_low_highIdentityLink)_LOSSESBaseLossAbsoluteErrorHalfBinomialLossHalfGammaLossHalfMultinomialLossHalfPoissonLossHalfSquaredErrorHalfTweedieLossHalfTweedieLossIdentityPinballLoss)assert_all_finite)create_memmap_backed_dataskip_if_32bitc                 "    g | ]} |            S  r   ).0losss     =lib/python3.11/site-packages/sklearn/_loss/tests/test_loss.py
<listcomp>r    #   s    000T$$&&000    g      ?)quantile      power      g      @c                     t          | t                    rW| }|j        j        }t	          |d          r|d|j        j         dz  }n#t	          |d          r|d|j        j         dz  }|S t          |           S )Nr"   z
(quantile=)r%   z(power=)	
isinstancer   	__class____name__hasattrclossr"   r%   str)paramr   names      r   loss_instance_namer2   3   s    %"" 	~&4$$ 	27!47777DDT7## 	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[   @   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'            (@)r@   	full_like)funcxepsh
f_minus_2h
f_minus_1h	f_plus_1h	f_plus_2hs           r   numerical_derivativeri   e   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                 X   | j         rt          j        dd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        |d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.r   	   
   numr?   N      ?r&   r'   rZ   rY   )rC   r@   linspacer   rO   rR   r_r;   rS   r<   in_y_true_rangeshaperL   rD   in_y_pred_rangerK   r   )r   rZ   r;   r<   ny_predrY   s          r   test_loss_boundaryry   s   s     0Qr***'(<==	TS$B/// ) 9vt3778* :vt3889'''''QA#D$899IC /1a&!!{3!444qqq!ta&A,./qqq!ta&A,./qqq!tS$A...''''' Y^^F++NIIVNI;;;;;r!   )r4   r   皙?r5   rz   r5   皙      ?r?   )r{   r|   r   rz   r5   )rz   rp   ?g?)r4   r|   r   r4   )              ?r'   )r{   r|   r   rp   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)rt   r@   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)rv   r@   r   )r   y_pred_successy_pred_failr   s       r   test_loss_boundary_y_predr      r   r!   z'loss, y_true, raw_prediction, loss_truer   g      @r^             @g      ȿg      @g      ?r8   rE   r   )皙?rp   333333?r   r   c                      | t          j        |g          t          j        |g                    t          |dd          k    sJ dS )zTest losses at specific values.rq   dy=-q=)relabsN)r@   r   r   )r   rZ   rY   	loss_trues       r   test_loss_on_specific_valuesr      sg    L 4x!!"(N;K2L2L  		u%	0	0	01 1 1 1 1 1r!   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        |
|          }|r5t          |	d	
          }	t          |
d	
          }
|t          |d	
          }|                     |	|
|||           |                     |	|
|||           |                     |	|
||||           || j	        rt          j        |
|          }| 
                    |	|
||||            | |	|
|           |                     |	|           |                     |	|           t          | d          r|                     |
           t          | d          r|                     |	|
||||           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.
    r8   r3   rm   r9   r   rT   rU   rV   rW   Nr   dtypeT)aligned)rZ   rY   r   loss_outr   )rZ   rY   r   gradient_outr   )rZ   rY   r   r   r   r   )rZ   rY   r   r   hessian_outr   rZ   rY   r   rZ   r   predict_proba)rY   gradient_proba)rZ   rY   r   r   	proba_outr   )r[   rI   r@   r   
empty_liker   r   gradientloss_gradientrC   gradient_hessianfit_intercept_onlyconstant_to_optimal_zeror-   r   r   )r   r   r   r   r   r   r   r   rT   rZ   rY   s              r   test_loss_dtyper     s   $ 466DI9  FN ]]8$$F#**844N #!2(CCC}V9555}^9=== S*64@@@2>4PPP$5mTRRRMII%#     	MM%#     	%#     D.}^9===%#     	D~]SSSS6GGG!!}!MMMt_%% :.999t%&& 
)' 	 	
 	
 	
 	
 	

 
r!   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        |          }	t          |                     ||||
          | j                            ||||
                     t          |                     ||||          | j                            ||||                     | j        	                    |||||           | j        	                    |||||           t          ||           t          ||           | 
                    |||||           | j        
                    |||||	           t          ||           t          ||	           dS )z:Test that Python and Cython functions return same results.   r3   r   r9   r   r   r&   r   rn   rZ   rY   r   r   rZ   rY   r   r   rZ   rY   r   r   r   rZ   rY   r   r   r   N)r[   r@   rr   ru   r   r   r   r.   r   r   r   )
r   r   rZ   rY   out_l1out_l2out_g1out_g2out_h1out_h2s
             r   test_loss_same_as_C_functionsr   d  ss    :  FN Av|AFLOLLL]6""F]6""F]>**F]>**F]>**F]>**F		)'	 	 	
 	
 	
)'	 	 	
 	
   )'	 	 	
 	
 	
)'	 	 	
 	
   	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   r3   r   r   r   r&   r   rn   r   r   r   r   r   rZ   rY   r   r   r   axisr   )rtolN)r[   r@   rr   ru   r   r   r   r   r   r   r   shares_memoryr-   rC   r   sum)r   r   global_random_seedrZ   rY   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!   onesrA   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.
    r5   r3   r6   r   r   )ru   r   r>   r   N)r[   r@   r   float64rA   rB   normalrI   r   r   r   rC   r   )r   r   r   rT   rZ   rY   rX   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   r3   r   r9   r   r&   Nrq   )r[   ndimr   r   r   r   r   )r   rZ   rY   raw_prediction_2ds       r   test_graceful_squeezingr   N  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   rz   r?   rm   绽|=rm   )ru   r]   r   Nr&   r   r   rn   r   r   +=gV瞯<)atolr   )rC   r@   r   r*   rK   r   rL   r;   rR   r<   rS   clipinverserH   rE   rI   rJ   fullexprG   rr   ru   r   r   r   )	r   r   rY   rc   r;   r<   rZ   
loss_valueconstant_terms	            r   test_loss_of_perfect_predictionr   m  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   r3   r6   r   r   r&   r   rn   r   c                 4                         |           S Nr   )r   rb   r   r   rZ   s    r   	loss_funcz6test_gradients_hessians_numerically.<locals>.loss_func  s'    99 +    r!   gư>)rc   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   rb   rawkr   rY   r   rZ   s     r   r   z6test_gradients_hessians_numerically.<locals>.loss_func  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[   r@   rr   ru   r   rC   ri   r   approx_hessianr   rE   )r   r   r   rT   grd   r   	g_numericr   	h_numericr   rY   rZ   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       r9   )r  g     @]@g?)r  r   r   )binomial_lossr   rz   )r  ir   )r     r~   )poisson_lossr_   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   rb   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.
        rq   rZ   )r   r   rb   r   rZ   s    r   ra   ztest_derivatives.<locals>.func  s>     yy!  
 
)))889 	9r!   c                 2                         |           S )Nrq   r   r  s    r   fprimez test_derivatives.<locals>.fprime"  s    }}F1}===r!   c                 >                         |           d         S )Nrq   r&   )r   r  s    r   fprime2z!test_derivatives.<locals>.fprime2%  s!    $$F1$EEaHHr!   r5   gHj>)x0r  r  maxitertolr   r   r   rq   gƠ>)r   r@   r   r   ndarrayr   ravelr   rK   r   r   )r   r  rZ   ra   r  r  optimums   ` `    r   test_derivativesr    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   Nr8   r   rz   r'   r   c                     j         st          j        |           }n/t          j        t          j        | j        f                    } |          S )N)ru   r]   ru   r   )rC   r@   r   ascontiguousarraybroadcast_torE   )rb   rY   r   rT   r   rZ   s     r   funz%test_loss_intercept_only.<locals>.funN  ss    ! 	WI1EEENN1)T^)DEEE N t)'
 
 
 	
r!   gHz>r  r5   )r  optionsr   r   r   )r   gvIh%<=SLSQPr&   )r  r%  methodconstraintsr   r   r   r  )rC   rK   r   r@   rr   rH   rI   r   rE   r   r   r   r`   ru   tupler   r   r   rb   r   r   zerosr	   r   tiler   )r   r   ar$  optgradrT   rZ   s   ``    @@r   test_loss_intercept_onlyr0  :  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)r@   
percentile)rb   s    r   <lambda>r5    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.
    r8  r&   rp   r5   r>   r  N)r@   rA   rB   r8  getattrr   r   r   rK   r   r*   r   r   rO   rR   fillr;   rS   r<   )r   ra   random_distr   rX   y_trainbaseline_predictions          r    test_specific_fit_intercept_onlyr?  }  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&   r5   r>   r  r   Nrm   r!  )r@   rA   rB   r   randintrI   r   r   ru   r+  r   r   meanr   logrK   r   r   )rX   rE   r   r=  r>  pr   s          r   (test_multinomial_loss_fit_intercept_onlyrE    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                    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      Nrp   r&   rq   )r@   rA   rB   r   r   rA  rI   r   r   rD   r   r   )r   rX   rT   binommultinomr=  rY   raw_multinoms           r   "test_binomial_and_multinomial_lossrJ    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!   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   r3   r6   r   r   r&   r   r   r&  r   )NNNr   r   )r[   r-   r   ru   rE   r@   r   r   r   r   r   r   )r   r   rT   rZ   rY   r   r/  s          r   test_predict_probarL    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.
    r8   r   r  )rT   r   rM  )r&   rN  N)r@   r   init_gradient_and_hessianconstant_hessianru   rC   rE   r   flagsc_contiguousf_contiguous)r   r   r   rM  rT   r   r   s          r   test_init_gradient_and_hessiansrV    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.matchrT   r8   Nr   )pytestraises
ValueError	TypeErrorrQ  )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.rX  Nr   )rZ  r[  )r   r^  err_typer_  s       r   #test_loss_init_parameter_validationrc  5  s    ( 
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   r3   r6   r9   r   rq   N)r[   pickledumpsloadsr   )r   rT   rZ   rY   pickled_lossunpickled_losss         r   test_loss_picklerj  M  s     I9  FN <%%L\,//N4vn===f^DDDB B      r!   rD  )r#   r   r&   r}   r'   r?   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$   rm   r9   )r   rT   rW   rq   r'   N)	r   r   r[   rK   r   r   r   r   r   )rD  half_tweedie_loghalf_tweedie_identityrT   rZ   rY   rx   loss_logloss_identitygradient_loghessian_loggradient_identityhessian_identitys                r   %test_tweedie_log_identity_consistencyrt  _  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!   )r3   r6   r9   )Nre  numpyr@   numpy.testingr   r   rZ  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   sklearn.utilsr   sklearn.utils._testingr   r   listvalues
ALL_LOSSESLOSS_INSTANCESr2   r[   ri   markparametrizery   infY_COMMON_PARAMSY_TRUE_PARAMSY_PRED_PARAMSr   r   rC  r   float32r   r   r   r   r   r   r   r  r  r0  rB  medianr?  rE  rJ  rL  rV  int64r`  r]  r\  rc  rj  rt  r   r!   r   <module>r     s         = = = = = = = =                   $ # # # # # @ @ @ @ @ @ @ @                          , + + + + + K K K K K K K K T.'.""##
00Z000 KO$O!O!O!O#!$$$!$$$!$$$#&&& 
 
 
 CE"" "" "" ""JU U U 5GHH< < IH<J ,,,w.?@]__)))RVGRV+<=[]]'''26'26):;_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 :;%0 _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 -				S#q)	#sA&	c	"	"	"Ca0	d	#	#	#S#~>	d	#	#	#S#x8			CAFBF1II,=>	#vrvayy&"&))e*;<	q	!	!	!3q		3DE	 	 q	)	)	)3QVRVAYY5FG	 	 q	)	)	)3VRVAYY5FG	 	 q	)	)	)35RS				T626!99fbfQii$:J.JK!,,,OOIooo&&,		
  !,,,OOIooo&&,		
  !,,,OOIooo&&,		
3@ 	E  # #H1 1I# #H1 ,,*UDM::bj"*%=>>rz2:&>??4)44$++$++q!f--Q
 Q
 .- ,+ ,+ 54 @? ?> ;: -,Q
h 5GHH4/::M$ M$ ;: IHM$` 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 / / />/ / /.  " 5GHH( ( IH(V ,,4/::2:rz":;;*--!* !* .- <; ;: -,!*H ,, bhM"(MMM	
 R R  -,R % B		
 O)		
 
z3'5TU $ % $ 5GHH  IH" 55566) ) 76) ) )r!   