o
    \i>                 	   @   s  d dl Z d dlmZ d dlZd dlZd dlm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mZmZmZmZ d d	lmZmZmZmZm Z m!Z!m"Z" d d
l#m$Z$m%Z%m&Z& d dl'm(Z(m)Z)m*Z*m+Z+m,Z, d dl-m.Z. d dl/m0Z0 d dl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 d dl8m9Z9 d dl:m;Z;m<Z<m=Z=m>Z>m?Z? d dl@mAZAmBZB d dlCmDZDmEZEmFZFmGZGmHZHmIZI g dZJdZKdZLe
M ZNeNjOeNjPZQZReSeQjTd  ZUejVWd ZXeXYeU eUdd ZUeQeU eReU ZQZRe
Z Z[e[jOe[jPZ\Z]dd Z^dd Z_ej`ddgddd Zaejbcd eJejbcd!d"d#gd$d% Zdejbcd eJejbcd!d"d#gd&d' Zeejbcd eJejbcd!d"d#gd(d) Zfejbcd eJejbcd!d"d#gd*d+ Zgejbcd eJejbcd!d"d#gd,d- Zhejbcd eJejbcd!d"d#gd.d/ Ziejbcd eJejbcd!d"d#gejbcd0dgeG ejbcd1d2d3gd4d5 Zjd6d7 Zkd8d9 Zld:d; Zmd<d= Znd>d? Zod@dA ZpejbcdBg dCejbcdDeGdEdF ZqejbcdGg dHejbcdId"d#gejbcdDeGdJdK ZrejbcdGg dHejbcdId"d#gejbcdDeGdLdM Zs	N	N	O	P	Q	R	S	S	"	#	#	ddTdUZtejbcdVdWdX eg dYdgeG D ejbcdZg d[d\d] Zuejbcd^d_d`gejbcdaejvgeG ejbcdbdcddgejbcd!d"d#gejbcdeg dfdgdh Zwdidj Zxejbcd^d_d`gejbcdaejvgeG ejbcdkdldmgejbcdng dodpdq Zyejbcd0dgeG ejbcdrg dsdtdu Zzdvdw Z{dxdy Z|ejbcdzed#d{efed#d{efgd|d} Z}ejbcdze efe efgejbcd~ddgdd Z~dd Zdd Zdd Zdd Zejbcddde^gejbcd~de*dgejbcd0dgeG dd Zejbcd~de*dgejbcd0dgeG dd Zdd Zdd Zejbjcde6 e5dejbjcdeBege9dejbjcded_dge9ddd Zejbcde7d#ddd Zejbcdee2dd Zejbcde{e|eeeefejbcdDeGdd Zdd Zejbcdeefdd Zdd Zejbcddde_gdd Zejbcddde^gdd Zejbcdeegdd Zejbcd~ddgejbcdeegdd Zdd Zdd Zejbcdddgddggejbcd0eEeF eG eH eI dd Zdd ZejbcdeegejbcdddiedfddiedfddiedfgddɄ Zejbcdeegdd˄ Zdd̈́ ZejbdΡddЄ Zejbcd g dѢejbcdd"d#gejbcdDeGddԄ Zejbcd g dբejbcdDeGddׄ Zejbcdd"d#gejbcdDeGddل Zejbcdd#d"gejbcddedܡgejbcdejgeG ejbcd g dޢdd Zejbcd g ddd Zdd Zejbcd g dejbcdedQdd Zdd Zejbcdei fed~difed~difgdd Zejbcd ddgejbcd!d"d#gejbcd1g ddd Zejbcd!d"d#gejbcd1g ddd Zejbcd g ddd Zejbcd1g ddd Zejbcd1g ddd Zdd Zejbcd!d#d"gejbcd0dgeG ejbcdd dgejbcd eJdg dd Zejbcdd#d"gejbcd!d#d"gejbcddQdgdd Zdd Zdd	 Zejbcd
eege	d"ddd Zejbcde efe efge	d"ddd ZdS (      N)product)linalg)config_contextdatasets)clone)make_classificationmake_low_rank_matrixmake_multilabel_classificationmake_regression)ConvergenceWarning)LinearRegressionRidgeRidgeClassifierRidgeClassifierCVRidgeCVridge_regression)_check_gcv_mode	_RidgeGCV_solve_cholesky_solve_cholesky_kernel_solve_lbfgs
_solve_svd_X_CenterStackOp)
get_scorermake_scorermean_squared_error)GridSearchCV
GroupKFoldKFoldLeaveOneOutcross_val_predict)minmax_scale)check_random_state)_NUMPY_NAMESPACE_NAMES_atol_for_type_convert_to_numpy_get_namespace_device_dtype_ids)yield_namespace_device_dtype_combinationsyield_namespaces)_get_check_estimator_ids)assert_allcloseassert_almost_equalassert_array_almost_equalassert_array_equalignore_warnings)_array_api_for_tests check_array_api_input_and_values)	_IS_32BITCOO_CONTAINERSCSC_CONTAINERSCSR_CONTAINERSDOK_CONTAINERSLIL_CONTAINERS)svd	sparse_cgcholeskylsqrsagsaga)r8   r;   )r8   r9   r:   r;   r<      c                 K   s   t | |kS N)npmeany_testy_predkwargs rE   /var/www/www-root/data/www/176.119.141.140/sports-predictor/venv/lib/python3.10/site-packages/sklearn/linear_model/tests/test_ridge.py_accuracy_callableY   s   rG   c                 C   s   | | d   S )N   )r@   )rB   rC   rE   rE   rF   _mean_squared_error_callable]   s   rI   longwide)paramsc                 C   s  |j dkr
d\}}nd\}}t||}tj| }t||||d}d|dddf< t|\}}}	t|dks:J |ddd|f |dd|df }
}|	d|ddf |	|dddf }}|j dkr|j	d	d
|d}|| }|||j
|| dd  7 }n|j	d	d
|d}|jtd|  |
j | }d}|t| }d|d< t|j| | |j| }|||  }|||  }tj|tj|k sJ ||||fS )aD  Dataset with OLS and Ridge solutions, well conditioned X.

    The construction is based on the SVD decomposition of X = U S V'.

    Parameters
    ----------
    type : {"long", "wide"}
        If "long", then n_samples > n_features.
        If "wide", then n_features > n_samples.

    For "wide", we return the minimum norm solution w = X' (XX')^-1 y:

        min ||w||_2 subject to X w = y

    Returns
    -------
    X : ndarray
        Last column of 1, i.e. intercept.
    y : ndarray
    coef_ols : ndarray of shape
        Minimum norm OLS solutions, i.e. min ||X w - y||_2_2 (with minimum ||w||_2 in
        case of ambiguity)
        Last coefficient is intercept.
    coef_ridge : ndarray of shape (5,)
        Ridge solution with alpha=1, i.e. min ||X w - y||_2_2 + ||w||_2^2.
        Last coefficient is intercept.
    rJ   )      )rN   rM   )	n_samples
n_featureseffective_rankrandom_state   NMbP?
   lowhighsizer[   rH   r   )rT   rT   )paramminr?   randomRandomStater   r   r7   alluniformnormalTdiagidentitysolvenorm)global_random_seedrequestrO   rP   krngXUsVtU1U2Vt1_coef_olsyalphad
coef_ridgeR_OLSR_RidgerE   rE   rF   ols_ridge_dataseta   s6   


**
r|   solverfit_interceptTFc                 C   s|  |\}}}}d}t |d| | dv rdnd|d}	|t| }
|||  }dt|d t|
d   }tdi |	}|d	d	d	d
f }|rL|d
 }n||jdd }||  }d}||| |d	d
 }|jt|ksrJ t	|j
| |||t|ksJ tdi |	j||t|jd d}|jt|ksJ t	|j
| |||t|ksJ |j| ksJ d	S )zTest that Ridge converges for all solvers to correct solution.

    We work with a simple constructed data set with known solution.
          ?Tr;   r<   V瞯<绽|=rw   r~   r}   tolrR   rS   rH   NrT   r   axissample_weightrE   )dictr?   r@   sumr   fit
intercept_pytestapproxr*   coef_scoreonesshapesolver_)r}   r~   r|   ri   rm   rv   rt   coefrw   rL   res_null	res_RidgeR2_Ridgemodel	interceptrE   rE   rF   test_ridge_regression   s:   	 
&r   c                 C   s   |\}}}}|j \}}	d}
t|
d || | dv rdnd|d}|ddddf }d	tj||fd
d }tj|t||	d
 ksBJ |rI|d }n||jdd }||  }d}||| |dd }|j	t
|ksoJ t|jtj||f dd dS )a  Test that Ridge converges for all solvers to correct solution on hstacked data.

    We work with a simple constructed data set with known solution.
    Fit on [X] with alpha is the same as fit on [X, X]/2 with alpha/2.
    For long X, [X, X] is a singular matrix.
    r   rH   r   r   r   r   NrT         ?rS   r   r   :0yE>atol)r   r   r?   concatenater   matrix_rankr^   r@   r   r   r   r   r*   r   r_r}   r~   r|   ri   rm   rv   rt   r   rO   rP   rw   r   r   rE   rE   rF    test_ridge_regression_hstacked_X   s,   

r   c                 C   s   |\}}}}|j \}}	d}
td|
 || | dv rdnd|d}|ddddf }tj||fd	d
}tj|t||	ks>J tj||f }|rL|d }n||jd	d
 }||  }d	}|	|| |dd }|j
t|ksrJ t|j|dd dS )aJ  Test that Ridge converges for all solvers to correct solution on vstacked data.

    We work with a simple constructed data set with known solution.
    Fit on [X] with alpha is the same as fit on [X], [y]
                                                [X], [y] with 2 * alpha.
    For wide X, [X', X'] is a singular matrix.
    r   rH   r   r   r   r   NrT   r   r   r   r   )r   r   r?   r   r   r   r^   r   r@   r   r   r   r   r*   r   r   rE   rE   rF    test_ridge_regression_vstacked_X   s.   

r   c                 C   s:  |\}}}}|j \}}	d}
t|
|| | dv rdnd|d}td
i |}|r:|ddddf }|d }|dd }nd}||| ||	ksH|sZ|jt|ksRJ t|j| dS t|	|| t|| | | t
jt
j|j|jf t
jt
j||f ksJ tjdd	 |jt|ksJ t|j| dS )a  Test that unpenalized Ridge = OLS converges for all solvers to correct solution.

    We work with a simple constructed data set with known solution.
    Note: This checks the minimum norm solution for wide X, i.e.
    n_samples < n_features:
        min ||w||_2 subject to X w = y
    r   r   r   r   r   NrT   1Ridge does not provide the minimum norm solution.reasonrE   )r   r   r   r   r   r   r   r*   r   predictr?   r   rh   r   xfail)r}   r~   r|   ri   rm   rv   r   rt   rO   rP   rw   rL   r   r   rE   rE   rF   !test_ridge_regression_unpenalized(  s8   

r   c                 C   sp  |\}}}}|j \}}	d}
t|
|| | dv rdnd|d}|r3|ddddf }|d }|dd }nd}dtj||fd	d
 }tj|t||	ksMJ ||| ||	ksY|sx|jt	
|kscJ | dkrkt	  t|jtj||f  dS t||| tjtj|j|jf tjtj|||f ksJ t	jdd |jt	
|ksJ t|jtj||f  dS )a^  Test that unpenalized Ridge = OLS converges for all solvers to correct solution.

    We work with a simple constructed data set with known solution.
    OLS fit on [X] is the same as fit on [X, X]/2.
    For long X, [X, X] is a singular matrix and we check against the minimum norm
    solution:
        min ||w||_2 subject to min ||X w - y||_2
    r   r   r   r   r   NrT   r   rS   r   r9   r   r   )r   r   r?   r   r   r   r^   r   r   r   r   skipr*   r   r   r   rh   r   r}   r~   r|   ri   rm   rv   r   rt   rO   rP   rw   r   r   rE   rE   rF   ,test_ridge_regression_unpenalized_hstacked_X_  s<   

r   c                 C   sT  |\}}}}|j \}}	d}
t|
|| | dv rdnd|d}|r3|ddddf }|d }|dd }nd}tj||fdd}tj|t||	ksKJ tj||f }||| ||	ks^|sp|j	t
|kshJ t|j| dS t||| tjtj|j	|jf tjtj||f ksJ t
jd	d
 |j	t
|ksJ t|j| dS )a  Test that unpenalized Ridge = OLS converges for all solvers to correct solution.

    We work with a simple constructed data set with known solution.
    OLS fit on [X] is the same as fit on [X], [y]
                                         [X], [y].
    For wide X, [X', X'] is a singular matrix and we check against the minimum norm
    solution:
        min ||w||_2 subject to X w = y
    r   r   r   r   r   NrT   r   r   r   )r   r   r?   r   r   r   r^   r   r   r   r   r   r*   r   r   rh   r   r   rE   rE   rF   ,test_ridge_regression_unpenalized_vstacked_X  s:   

r   sparse_containerrw   r   {Gz?c                 C   s@  |dur|r| t vrt  n
|s| tvrt  |\}}}}	|j\}
}tjdd|
d}t||| | dv r6dndd|d	}|dddd
f }tj	||fdd}tj
||f }tj
|d| f | }|rh|	d
 }n||jdd }||  }d}|dur||}|j|||d |	dd
 }	|jt|ksJ t|j|	 dS )zTest that Ridge with sample weights gives correct results.

    We use the following trick:
        ||y - Xw||_2 = (z - Aw)' W (z - Aw)
    for z=[y, y], A' = [X', X'] (vstacked), and W[:n/2] + W[n/2:] = 1, W=diag(W)
    Nr   rS   rX   r   r   r   順 )rw   r~   r}   r   max_iterrR   rT   r   r   )SPARSE_SOLVERS_WITH_INTERCEPTr   r    SPARSE_SOLVERS_WITHOUT_INTERCEPTr   rl   rb   r   r?   r   r   r@   r   r   r   r*   r   )r}   r~   r   rw   r|   ri   rm   rv   rt   r   rO   rP   swr   r   rE   rE   rF   $test_ridge_regression_sample_weights  s>   


r   c                  C   sX   t dd} tt| dgd}tttj}t|| dgd}ttj|j}t|| d S )NrT   rS   r   rw   )	
y_diabetesreshaper   
X_diabetesr?   dotrd   r   r,   )rv   r   K	dual_coefcoef2rE   rE   rF   test_primal_dual_relationship  s   r   c               
   C   sp   t jd} | d}| dd}d}tjt|d t||dddd d	d
 W d    d S 1 s1w   Y  d S )Nr      rW   z3sparse_cg did not converge after [0-9]+ iterations.matchr   r8           rS   )rw   r}   r   r   verbose)r?   r_   r`   randnr   warnsr   r   )rl   rv   rm   warning_messagerE   rE   rF   &test_ridge_regression_convergence_fail  s   
"r   c                  C   sN  t jd} d\}}| ||}| |}|d d t jf }t j|d| f }t }||| |jj	|fks9J |j
j	dksAJ t|jt jsJJ t|j
tsRJ ||| |jj	|fksaJ |j
j	dksiJ t|jt jsrJ t|j
t js{J ||| |jj	d|fksJ |j
j	dksJ t|jt jsJ t|j
t jsJ d S )Nr   r   rW   rS   rE   rS   rH   )rH   )r?   r_   r`   r   newaxisc_r   r   r   r   r   
isinstancendarrayfloat)rl   rO   rP   rm   rv   Y1YridgerE   rE   rF   test_ridge_shapes_type  s,   
r   c                  C   s   t jd} d\}}| ||}| |}t j|d| f }t }||| |j}||| t|jd | t|jd |d  d S )Nr   r   r   rS   )	r?   r_   r`   r   r   r   r   r   r+   )rl   rO   rP   rm   rv   r   r   r   rE   rE   rF   test_ridge_intercept5  s   
r   c                  C   s   t jd} d\}}| |}| ||}tddd}tdd}||| ||| t|j|j ||| ||| t|j|j d S )Nr   )r   rN   r   Frw   r~   r~   )	r?   r_   r`   r   r   r   r   r+   r   )rl   rO   rP   rv   rm   r   olsrE   rE   rF   test_ridge_vs_lstsqG  s   

r   c            	         s   t jd} d\}}}| || | ||t |t  fddtjD } fdddD }|D ]}t|| q9t	d d d}d	}t
jt|d
 |  W d    d S 1 sew   Y  d S )N*   )   rW   r   c                    s&   g | ]\}}t |d d |jqS )r9   rw   r}   r   r   r   ).0rw   target)rm   rE   rF   
<listcomp>h  s    z3test_ridge_individual_penalties.<locals>.<listcomp>c                    s$   g | ]}t |d d jqS )-q=)rw   r}   r   r   )r   r}   rm   	penaltiesrv   rE   rF   r   n  s    )r7   r8   r:   r9   r;   r<   rT   r   zCNumber of targets and number of penalties do not correspond: 4 != 5r   )r?   r_   r`   r   arangearrayziprd   r,   r   r   raises
ValueErrorr   )	rl   rO   rP   	n_targetscoef_choleskycoefs_indiv_pencoef_indiv_penr   err_msgrE   r   rF   test_ridge_individual_penalties\  s(   



"r   n_col)rE   r   )   csr_containerc           
      C   s   t jd}|dd}|d}|t|}|jdg| R  }|jdg| R  }t||||}t ||d d d f |  |d d d f g}	t|	||| t|	j	||j	| d S )Nr         	   )
r?   r_   r`   r   lenr   hstackr*   r   rd   )
r   r   rl   rm   X_msqrt_swr   Aoperatorreference_operatorrE   rE   rF   test_X_CenterStackOp|  s   
.r   r   ))rW   rS   )   r   )r      )rH   rH   )r   r   uniform_weightsc                 C   s   t jd}|j|  }|rt |jd }n|d| d }t |}t j|d|d}|| |d d d f  }|	|j
}	|||d d d f  }
tdd}||
|\}}t|| t|	| d S Nr   rS   )r   weightsTr   )r?   r_   r`   r   r   r   	chisquaresqrtaverager   rd   r   _compute_gramr*   )r   r   r   rl   rm   r   r   X_mean
X_centered	true_gramX_sparsegcvcomputed_gramcomputed_meanrE   rE   rF   test_compute_gram     



r  c                 C   s   t jd}|j|  }|rt |jd }n|d| d }t |}t j|d|d}|| |d d d f  }|j	
|}	|||d d d f  }
tdd}||
|\}}t|| t|	| d S r   )r?   r_   r`   r   r   r   r  r  r  rd   r   r   _compute_covariancer*   )r   r   r   rl   rm   r   r   r  r  true_covariancer  r	  computed_covr  rE   rE   rF   test_compute_covariance  r  r  d   r   rW   rS         *@      >@c                 C   s   t | ||||||d|d	\}}}|dkrt|g}||7 }tj|d||jdk}| }d|| < d||< |||8 }|
rW||t	|d | 7 }t	|d }|dkr_|d }|	rf|||fS ||fS )NT)	rO   rP   n_informativer   biasnoiseshuffler   rR   rS   r   r   )
r
   r?   asarrayr_   r`   binomialr   copyr   abs)rO   rP   proportion_nonzeror  r   r  X_offsetr  r  r   positiverR   rm   rv   cmask	removed_XrE   rE   rF   _make_sparse_offset_regression  s8   

r#  zsolver, sparse_containerc                 c   s,    | ]\}}|d u s|dv r||fV  qd S )N)r8   ridgecvrE   )r   r}   r   rE   rE   rF   	<genexpr>  s    r%  )r9   r;   r8   r:   r<   r$  z"n_samples,dtype,proportion_nonzero))r   float32皙?)(   r&  r   )r   float64皙?c                 C   s   d}|dkrdnd}t dd||||d\}}	t|}td|d	||	}
|j|d
d}|	j|d
d}	|d ur:||}| dkrEt|gd}n| drOd}d}nd}d }t|| |||d}|||	 t|j|
jddd t|j	|
j	ddd d S )Nr   g?g      I@g     @@rW      )r  rP   r  r  rR   rO   r7   )r}   rw   F)r  r$  alphasr;   gHz>r   r   )rw   r}   r   r   rR   rU   r   rtol)
r#  r!   r   r   astyper   
startswithr*   r   r   )r}   r  rO   dtyper   ri   rw   r  rm   rv   	svd_ridger   r   r   rE   rE   rF   test_solver_consistency  sB   

r4  gcv_moder7   eigenX_containerX_shape)r   r   )r   r   zy_shape, noise))r   r   )r   rS   r  )r   r        b@c              	   C   s   |\}}t |dkr|d nd}t|||dd|dd\}	}
|
|}
g d}t|||d	d
}t| ||d}||	|
 ||	}|||
 |jt|jksPJ t|j	|j	dd t|j
|j
dd d S )NrH   rT   rS   r   Fr   rO   rP   r   rR   r  r  r  rU   r'  r         $@g     @@neg_mean_squared_errorcvr~   r-  scoring)r5  r~   r-  rU   r/  )r   r#  r   r   r   alpha_r   r   r*   r   r   )r5  r7  r8  y_shaper~   r  rO   rP   r   rm   rv   r-  	loo_ridge	gcv_ridgeX_gcvrE   rE   rF   test_ridge_gcv_vs_ridge_loo_cv  s<   

	rJ  c            	   	   C   s   d} d\}}d}t |||ddddd\}}g d}t|d	|| d
}td	|| d}||| ||| |jt|jksIJ d|jd|jt|j|jdd t|j|jdd d S )Nexplained_variance)rW   r   rS   r   Fr   r=  r>  TrA  )r~   r-  rC  zgcv_ridge.alpha_=z, loo_ridge.alpha_=rU   rD  )	r#  r   r   rE  r   r   r*   r   r   )	rC  rO   rP   r   rm   rv   r-  rG  rH  rE   rE   rF   test_ridge_loo_cv_asym_scoringR  s0   

rL  rP   r   r   zy_shape, fit_intercept, noise))r9  Tr   )r:  Tg      4@)r;  Tr<  )r;  Fr  c                    s  g d}t jd}t|dkr|d nd}td||dd|d\}	}
|
|}
d	|t|	 }||  d t	}t 
t |	jd | |t}|	  |
  }}t|	jd d
}|j|| d}t||d|d}||| t|j|d}|j|| d}t||||d}|j|jkr||j}|| d  fddt |	jd D t ||	}t|d| |d}|j||
|d t|dkr|jd d d d ||jf }n|jd d ||jf }|jt|jksJ t|dd t|j|jdd t|j|jdd d S )Nr>  r   rH   rT   rS   r   F)rO   rP   r   rR   r  r  r   )n_splits)groupsr@  )r-  rB  rC  r~   r   rB  c                    s"   g | ]}t j |k d dqS )r   r   )r?   r   )r   iindiceskfold_errorsrE   rF   r     s    z1test_ridge_gcv_sample_weights.<locals>.<listcomp>T)r-  store_cv_resultsr5  r~   r   rU   rD  )r?   r_   r`   r   r#  r   r   r^   r0  intrepeatr   r   r   r   splitr   r   r   rE  r    r  cv_results_indexr   r   r*   r   r   )r5  r7  r~   rP   rF  r  r-  rl   r   rm   rv   r   X_tiledy_tiledrB  splitskfold	ridge_regpredictionsrI  rH  
gcv_errorsrE   rQ  rF   test_ridge_gcv_sample_weightsr  sf   



"ra  z2mode, mode_n_greater_than_p, mode_p_greater_than_n))Nr7   r6  )autor7   r6  )r6  r6  r6  )r7   r7   r7   c                 C   sJ   t ddd\}}| d ur| |}t|||ksJ t|j||ks#J d S )Nr   rH   )rO   rP   )r
   r   rd   )r   modemode_n_greater_than_pmode_p_greater_than_nrm   rt   rE   rE   rF   test_check_gcv_mode_choice  s
   rf  c                 C   s  t jd }g }| d u rt d}}n| t d}}t|d}||t |j}|| t}tt	dd}t
d|d}	||	j|t |	jt|ksKJ dd }
t|
}t
d|d}||j|t |jt|kskJ td	}t
d|d}||t |jt|ksJ | d u r|j|tt|d
 |jt|ksJ tttfj}||| ||}||t ||}tt||fj|dd |S )Nr   TFr   )greater_is_better)r~   rC  c                 S   s   t | | S r>   )r   )xrv   rE   rE   rF   func  s   z_test_ridge_loo.<locals>.funcr@  r   h㈵>rD  )r   r   r   r   r   rE  appendr.   r   r   r   r   r   r   r?   r   vstackrd   r   r*   )r   rO   retrm   r~   	ridge_gcvrE  frC  
ridge_gcv2ri  
ridge_gcv3scorer
ridge_gcv4r   Y_predrC   rE   rE   rF   _test_ridge_loo  sB   




ru  c                 C   s   | d u rt n| t }t }||t || t|jjdks"J t|j	t
ju s,J td}|j|d ||t || t|jjdksKJ t|j	t
ju sUJ d S )NrS   r   rO  )r   r   r   r   r   r   r   r   typer   r?   r)  r   
set_params)r   rm   ridge_cvrB  rE   rE   rF   _test_ridge_cv	  s   

ry  zridge, make_dataset)rT  c                 C   s.   |ddd\}}|  || t| drJ d S )N   r   rO   rR   rX  )r   hasattr)r   make_datasetrm   rv   rE   rE   rF   $test_ridge_gcv_cv_results_not_stored  s   	r~  rB  r   c                 C   sL   |ddd\}}| j d|d | || t| dsJ t| jts$J d S )Nrz  r   r{  F)rT  rB  best_score_)rw  r   r|  r   r  r   )r   r}  rB  rm   rv   rE   rE   rF   test_ridge_best_score)  s
   r  c               	      s  t jd} d\}}}| ||}t |d d dgf t d|ft |d d dgf dt d|f  t |d d dgf dt d|f  | ||  d fd	d
|jD }tdd |}t	||j
 tt|j
d |j|j tddd |}|j
j|fksJ |jj|fksJ |jj|t|fksJ tdddd |}|j
j|fksJ |jj|fksJ |jj||dfksJ tddd |d d df }t |j
sJ t |jsJ |jj|tfksJ tddd |}t	||j
 tt|j
d |j|j tt dd}d}tjt|d | | W d    n	1 s?w   Y  tddd}tjt|d | | W d    d S 1 sew   Y  d S )Nr   )r   r   r   r   rS   g?rH   rU   )rS   r    c                    s    g | ]}t d  |jqS )r,  )r   r   rE  )r   r   rm   r-  rE   rF   r   J  s     z6test_ridge_cv_individual_penalties.<locals>.<listcomp>T)r-  alpha_per_targetr   )r-  r  rT  r2)r-  r  rC  )r-  rB  r  z3cv!=None and alpha_per_target=True are incompatibler   rz  )r?   r_   r`   r   r   r   rd   r   r   r-   rE  r,   r   r   r   r  rX  r   isscalarr   r   r   r   )rl   rO   rP   r   rv   optimal_alphasrx  msgrE   r  rF   "test_ridge_cv_individual_penalties7  s`   
"&&
$r  c                 C   s>   | d u rt n| t }tdd}||t t||tdS )NFr   r   )r   r   r   r   r?   roundr   )r   rm   r   rE   rE   rF   _test_ridge_diabetes~  s   
r  c                 C   s   | d u rt n| t }tttfj}t jd }tdd}||| |jjd|fks,J |	|}||t |	|}t
t||fj|dd d S )NrS   Fr   rH   r   decimal)r   r?   rl  r   rd   r   r   r   r   r   r,   )r   rm   r   rP   r   rt  rC   rE   rE   rF   _test_multi_ridge_diabetes  s   



r  c                 C   s   t tjd }tjd }| d u rtn| t}t t fD ]"}||t |jj||fks/J |	|}t 
t|kdks?J qtd}t|d}||t |	|}t 
t|kdks_J d S )Nr   rS   gHzG?r   rO  g?)r?   uniquey_irisr   X_irisr   r   r   r   r   r@   r   )r   	n_classesrP   rm   regrC   rB  rE   rE   rF   _test_ridge_classifiers  s   



r  rC  accuracyr   c                 C   sJ   | d u rt n| t }t|rt|n|}t||d}||t| d S )N)rC  rB  )r  callabler   r   r   r  r   )r   rC  rB  rm   scoring_clfrE   rE   rF   "test_ridge_classifier_with_scoring  s   r  c                 C   sz   dd }| d u r
t n| t }tjdddd}t|t||d}||t |jt	dks/J |j
t	|d	 ks;J d S )
Nc                 [   s   dS )NzG?rE   rA   rE   rE   rF   _dummy_score  s   z:test_ridge_regression_custom_scoring.<locals>._dummy_scorerH   r   )num)r-  rC  rB  r  r   )r  r?   logspacer   r   r   r  r  r   r   rE  )r   rB  r  rm   r-  r  rE   rE   rF   $test_ridge_regression_custom_scoring  s   r  c                 C   sl   | d u rt n| t }tddd}||t ||t}tddd}||t ||t}||ks4J d S )Nrj  F)r   r~   rU   )r   r   r   r   r   )r   rm   r   r   ridge2score2rE   rE   rF   _test_tolerance  s   r  c                 C   s  t ||}t|}t|}|j||d}|j||d}	||| |j}
|j}tddO t	|||	}|j}|j
dksAJ |j|jksIJ tt||d|
t|d |j}|j
dks`J |j|jkshJ tt||d|t|d W d    d S 1 sw   Y  d S )NdeviceTarray_api_dispatch)rN   )xpr   rE   )r/   r  r0  r  r  r   r   r   r   r   r   r2  r*   r%   r$   )name	estimatorarray_namespacer  
dtype_namer  	X_iris_np	y_iris_np	X_iris_xp	y_iris_xpcoef_npintercept_npestimator_xpcoef_xpintercept_xprE   rE   rF   check_array_api_attributes  s6   




"r  z#array_namespace, device, dtype_name)idscheckr  r}   c                 C   s   | j j}||| |||d d S )N)r  r  )	__class____name__)r  r  r  r  r  r  rE   rE   rF   test_ridge_array_api_compliance  s   r  r  )include_numpy_namespacesc              
   C   s  t | d d}|td d }|td d }tjd d j}|ddh D ]F}t||dkd}d	|j d
| d}tj	t
|d# tdd ||| W d    n1 sXw   Y  W d    n1 sgw   Y  q&tddd}d|j d}tj	t
|d# tdd ||| W d    n1 sw   Y  W d    n1 sw   Y  t }d|j d}tjt|d, tdd ||| W d    n1 sw   Y  W d    d S W d    d S 1 sw   Y  d S )Nr  r   r}   r   rb  r7   lbfgsr}   r  z Array API dispatch to namespace z" only supports solver 'svd'. Got 'z'.r   Tr  zYThe solvers that support positive fitting do not support Array API dispatch to namespace zc. Please either disable Array API dispatch, or use a numpy-like namespace, or set `positive=False`.z&Using Array API dispatch to namespace z with `solver='auto'` will result in using the solver 'svd'. The results may differ from those when using a Numpy array, because in that case the preferred solver would be cholesky. Set `solver='svd'` to suppress this warning.)r/   r  r  r  r   _parameter_constraintsoptionsr  r   r   r   r   r   r   UserWarning)r  r  r  r  available_solversr}   r   expected_msgrE   rE   rF   6test_array_api_error_and_warnings_for_solver_parameter  sL   
"r  c              	   C   s   t | d d}|td d }|td d }t }d}t + tjd|td t	dd |
|| W d    n1 s@w   Y  W d    n1 sOw   Y  t	dd tddd	
|| W d    d S 1 sow   Y  d S )
Nr  r   zkResults might be different than when Array API dispatch is disabled, or when a numpy-like namespace is usederror)messagecategoryTr  rb  r  )r/   r  r  r  r   warningscatch_warningsfilterwarningsr  r   r   )r  r  r  r  r   r  rE   rE   rF   )test_array_api_numpy_namespace_no_warning:  s    
"r  	test_funcc                 C   s:   | d }| |}|d ur|d urt ||dd d S d S d S )Nr   r  )r,   )r  r   	ret_dense
ret_sparserE   rE   rF   test_dense_sparseR  s
   r  c                  C   sX  t ddgddgddgddgddgg} g d}td d}|| | t|ddggt d	g td	d
id}|| | t|ddggt dg tdd}|| | t|ddggt d	g t ddgddgddgddgg} g d}td d}|| | tdd}|| | t|jdksJ t|j	|j	 t|j
|j
 d S )N      r   皙r   r   rS   rS   rS   rT   rT   class_weightr*  rS   rU   rT   balanced)rS   rS   rT   rT   rH   )r?   r   r   r   r-   r   r   classes_r,   r   r   )rm   rv   r  regarE   rE   rF   test_class_weightsh  s(   (

"

r  r  c                 C   s   |  }| tjtj | dd}| tjtj t|j|j ttjj}|tjdk  d9  < dddd}|  }| tjtj| | |d}| tjtj t|j|j |  }| tjtj|d  | |d}| tjtj| t|j|j d	S )
z5Check class_weights resemble sample_weights behavior.r  r  rS   r  r   g      Y@)r   rS   rH   rH   N)	r   irisdatar   r+   r   r?   r   r   )r  reg1reg2r   r  rE   rE   rF   "test_class_weight_vs_sample_weight  s$   


r  c                  C   s   t ddgddgddgddgddgg} g d}td g dd}|| | td	d
ig dd}|| | t|ddggt dg d S )Nr  r   r  r   r   r  )r   r'  rS   )r  r-  rS   rU   )r   r'  rS   rW   gɿrH   rT   )r?   r   r   r   r-   r   )rm   rv   r  rE   rE   rF   test_class_weights_cv  s   ("r  r@  c                 C   s   t jd}d}d}|||}g d}t|}t| r t| n| }t|d d|d}||}	|||	 |j	j
||fks?J d}
|||
}	|||	 |j	j
||
|fksXJ tdd| d}tjtd	d
 |||	 W d    d S 1 sxw   Y  d S )Nr   r   r   r'  r   r?  Tr-  rB  rT  rC  r   )rB  rT  rC  zcv!=None and store_cv_resultsr   )r?   r_   r`   r   r   r  r   r   r   rX  r   r   r   r   )rC  rl   rO   rP   rh  r-  n_alphasr  rrv   r   rE   rE   rF   test_ridgecv_store_cv_results  s&   
"r  c           	      C   s   t ddgddgddgddgddgg}t g d}|jd }g d}t|}t| r0t| n| }t|d d|d	}d
}||| |jj|||fksMJ t g dg dg dg	 }|jd
 }||| |jj|||fkssJ d S )Nr  r   r  r   r   r  r  Tr  rS   )rS   rT   rS   rT   rS   )rT   rT   rS   rT   rT   )
r?   r   r   r   r  r   r   r   rX  	transpose)	rC  rh  rv   rO   r-  r  r  r  r   rE   rE   rF   )test_ridge_classifier_cv_store_cv_results  s(   (

r  	Estimatorc                 C   s   t jd}d}d\}}| tu r||}n|dd|}|||}| |d}|j|u s6J d| j d||| t	|jt 
| d S )Nr   r  r   r   rH   r,  z`alphas` was mutated in `z
.__init__`)r?   r_   r`   r   r   randintr-  r  r   r-   r  )r  rl   r-  rO   rP   rv   rm   	ridge_estrE   rE   rF   test_ridgecv_alphas_conversion  s   
r  c           	      C   s   t jd}d}d\}}|tu r||}n|dd|}|||}||| d}| du rMtjtdd |	|| W d   dS 1 sFw   Y  dS |	|| dS )	z1Check alpha=0.0 raises error only when `cv=None`.r   )r   r   r?  r  rH   r-  rB  Nz"alphas\[0\] == 0.0, must be > 0.0.r   )
r?   r_   r`   r   r   r  r   r   r   r   )	rB  r  rl   r-  rO   rP   rv   rm   r  rE   rE   rF   test_ridgecv_alphas_zero	  s   "r  c                  C   s   t jd} d}dD ]M\}}| |}| ||}d| | }td}t||d}|j|||d d|i}	tt	 |	|d	}
|
j|||d |j
|
jjksOJ t|j|
jj q
d S )
Nr   r  )rz  r   r   r   r   r  r   rw   rO  )r?   r_   r`   r   randr   r   r   r   r   rE  best_estimator_rw   r,   r   )rl   r-  rO   rP   rv   rm   r   rB  r$  
parametersgsrE   rE   rF   test_ridgecv_sample_weight  s   
r  c               	      sP  ddg} ddg}t jd}t| |D ]\}}||| ||||d d }d}d}|d d t jf |t jd d f tdd |  |  |  fdd	} fd
d}	d}
tj	t
|
d |  W d    n1 sw   Y  d}
tj	t
|
d |	  W d    n1 sw   Y  qd S )NrH   r   r   rS   r   g       @r   c                            d S r>   r   rE   )rm   r   sample_weights_not_OKrv   rE   rF   fit_ridge_not_okO     zStest_raises_value_error_if_sample_weights_greater_than_1d.<locals>.fit_ridge_not_okc                      r  r>   r  rE   )rm   r   sample_weights_not_OK_2rv   rE   rF   fit_ridge_not_ok_2R  r  zUtest_raises_value_error_if_sample_weights_greater_than_1d.<locals>.fit_ridge_not_ok_2z)Sample weights must be 1D array or scalarr   )r?   r_   r`   r   r   r   r   r   r   r   r   )
n_samplessn_featuressrl   rO   rP   sample_weights_OKsample_weights_OK_1sample_weights_OK_2r  r  r   rE   )rm   r   r  r  rv   rF   9test_raises_value_error_if_sample_weights_greater_than_1d7  s6   

r  zn_samples,n_featuresrH   c           
      C   s   t jd}tddd}tddd}|| |}|| }|| d d }||}	|j|	||d |j|||d t|j|jdd	 d S )
Nr   r   Fr   rH   rS   r   rz  r  )r?   r_   r`   r   r   r   r,   r   )
rO   rP   r   rl   sparse_ridgedense_ridgerm   rv   sample_weightsr  rE   rE   rF   &test_sparse_design_with_sample_weights^  s   
r  c                  C   sJ   t ddgddgddgddgddgg} g d}tdd}|| | d S )	Nr  r   r  r   r   r  )rS   rW   r  r,  )r?   r   r   r   )rm   rv   r   rE   rE   rF   test_ridgecv_int_alphast  s   (
r  zparams, err_type, err_msgr-  )rS   rT   iz alphas\[1\] == -1, must be > 0.0)gr  g      $z"alphas\[0\] == -0.1, must be > 0.0)rS   r   1z1alphas\[2\] must be an instance of float, not strc                 C   sl   d\}}t ||}t dd|}tj||d | di ||| W d   dS 1 s/w   Y  dS )z?Check the `alphas` validation in RidgeCV and RidgeClassifierCV.r  r   rH   r   NrE   )rl   r   r  r   r   r   )r  rL   err_typer   rO   rP   rm   rv   rE   rE   rF   test_ridgecv_alphas_validation}  s   "r  c                 C   sL   d\}}t ||}| tu rt |}nt dd|}| dd|| dS )zCheck the case when `alphas` is a scalar.
    This case was supported in the past when `alphas` where converted
    into array in `__init__`.
    We add this test to ensure backward compatibility.
    r  r   rH   rS   r,  N)rl   r   r   r  r   )r  rO   rP   rm   rv   rE   rE   rF   test_ridgecv_alphas_scalar  s   r  c                  C   s6   t ddd} | tt | jjd tjd ksJ d S )Nr8   rS   )r}   r   r   )r   r   r   r   r   r   )r  rE   rE   rF   test_sparse_cg_max_iter  s   r  z-ignore::sklearn.exceptions.ConvergenceWarningc                  C   s   d} t t}}t|| dfj}tddD ]}dD ]}t||dd}||| t|j	t||  qqdD ]}t|ddd}||| |j	d u sLJ q6d S )	NrH   rS   rN   )r;   r<   r:   r   )r}   r   r   )r8   r7   r9   r'  )
r   r   r?   tilerd   ranger   r   r-   n_iter_)r   rm   rv   y_nr   r}   r  rE   rE   rF   test_n_iter  s   
r  )r:   r8   r  rb  with_sample_weightc                 C   s   | dk}t d||d\}}d}|r"tj|}d|j|jd d }| dkr(d	n| }	t|	d
|d}
t| d
|d}|
j|||d |j||||d t|
j	|j	 t|
j
|j
dd dS )a  Check that ridge finds the same coefs and intercept on dense and sparse input
    in the presence of sample weights.

    For now only sparse_cg and lbfgs can correctly fit an intercept
    with sparse X with default tol and max_iter.
    'sag' is tested separately in test_ridge_fit_intercept_sparse_sag because it
    requires more iterations and should raise a warning if default max_iter is used.
    Other solvers raise an exception, as checked in
    test_ridge_fit_intercept_sparse_error
    r  r   )rP   rR   r  Nr   r   r\   rb  r8   r   )r}   r   r  r   gƠ>rD  )r#  r?   r_   r`   rb   r   r   r   r*   r   r   )r}   r  ri   r   r  rm   rv   r   rl   dense_solverr   r  rE   rE   rF   test_ridge_fit_intercept_sparse  s   
r  )r<   r7   r9   c                 C   sl   t ddd\}}||}t| d}d| }tjt|d ||| W d    d S 1 s/w   Y  d S )Nr   r   )rP   rR   r  zsolver='{}' does not supportr   )r#  r   formatr   r   r   r   )r}   r   rm   rv   X_csrr  r   rE   rE   rF   %test_ridge_fit_intercept_sparse_error  s   

"r  c                 C   s:  t dd|dd\}}| rtj|}d|j|jd d }nd }||}tddd	d
dd}tdi |}	tdi |}
|	j|||d t	
  t	dt |
j|||d W d    n1 s`w   Y  t|	j|
jdd t|	j|
jdd tjtdd tdd	dd d|| W d    d S 1 sw   Y  d S )Nr   r   g      @)rP   rO   rR   r  r   r   r\   r;   Tr   r   )rw   r}   r~   r   r   r   r  -C6?rD  z"sag" solver requires.*r   rU   )r}   r~   r   r   rE   )r#  r?   r_   r`   rb   r   r   r   r   r  r  simplefilterr  r*   r   r   r   r   )r  ri   r   rm   rv   rl   r   r  rL   r   r  rE   rE   rF   #test_ridge_fit_intercept_sparse_sag  s.   


"r  return_interceptr   r  	container)rb  r8   r9   r:   r;   r<   r  c                 C   s  t d}|dd}g d}t||}d}| rd}||7 }||}	d\}
}tr*dnd	}|d
k}|dvr\| r\tjtdd t|	||
||| ||d W d   dS 1 sUw   Y  dS t|	||
|||| |d}| r|\}}t	||d|d t	||d|d dS t	||d|d dS )z=check if all combinations of arguments give valid estimationsr   r  r   )rS   rH   r'  r   g     @)rU   ư>rU   r  r  )r;   rb  zIn Ridge, only 'sag' solverr   )rw   r}   r   r  r  r   N)rw   r}   r   r  r  r   r   r/  r   )
r"   r  r?   r   r1   r   r   r   r   r*   )r  r   r  r}   rl   rm   
true_coefsrv   true_intercept	X_testingrw   r   r   r  outr   r   rE   rE   rF   .test_ridge_regression_check_arguments_validity  sV   
r  )r7   r8   r9   r:   r;   r<   r  c                 C   s  t jd}d}| dk}d\}}|||}||}|t j}|t j}	dt t jj }
t|| d|
|d}|	||	 |j
}t|| d|
|d}|	|| |j
}|j|jks\J |j|jksdJ ||j|jksoJ ||j|jkszJ t|j
|j
dd	d
 d S )Nr   r   r  r  rH     )rw   r}   r   r   r  r  gMb@?r  )r?   r_   r`   r   r0  r&  finfo
resolutionr   r   r   r2  r   r*   )r}   rl   rw   r  rO   rP   X_64y_64X_32y_32r   ridge_32coef_32ridge_64coef_64rE   rE   rF   test_dtype_matchS  s0   


r+  c                  C   s   t jd} t ddg}d\}}}| ||}| ||}|t j}|t j}t|dd}	|	|| |	j	}
t|dd}||| |j	}|
j
|j
ksPJ |j
|j
ksXJ |	|j
|j
kscJ ||j
|j
ksnJ t|	j	|j	dd d S )	Nr   r   r   )rz  r   rH   r9   r   r   r  )r?   r_   r`   r   r   r0  r&  r   r   r   r2  r   r+   )rl   rw   rO   rP   n_targetr#  r$  r%  r&  r'  r(  r)  r*  rE   rE   rF   test_dtype_match_choleskyx  s$   
r-  )r7   r9   r:   r8   r;   r<   r  seedc                 C   s   t j|}d\}}|||}||}t ||d||  }d}| dk}	t }
| dkr1dnd}t jt jfD ]}t|	||	||| |d |	dd	d
d
d|
|< q9|
t j j
t jks^J |
t j j
t jksiJ t|
t j |
t j |d d S )Nr  r   r   r  r8   rU   rj  r   r   F)	rw   r}   rR   r   r  r   r   return_n_iterr  r   )r?   r_   r`   r   r   r   r&  r)  r   r0  r2  r*   )r}   r.  rR   rO   rP   rm   r   rv   rw   r  resultsr   current_dtyperE   rE   rF   %test_ridge_regression_dtype_stability  s4   
r2  c                  C   sR   t dd\} }t| } | d d dd d f } |d d d }tdd| | d S )Nr   rR   rH   r;   r  )r
   r?   asfortranarrayr   r   )rm   rv   rE   rE   rF   test_ridge_sag_with_X_fortran  s
   
r5  zClassifier, paramsc                 C   s   t ddd\}}|dd}tj||gdd}| d	i |||}||}|j|jks/J t|dddf |dddf  tdd|| dS )
zRCheck that multilabel classification is supported and give meaningful
    results.rS   r   )r  rR   rT   r   Nr;   r  rE   )	r	   r   r?   r   r   r   r   r-   r   )
ClassifierrL   rm   rv   r   r  rt  rE   rE   rF   test_ridgeclassifier_multilabel  s   
"r7  rb  r  )rU   r   r'  r   c                 C   s   t ddgddgddgddgg}t dd	g}|r$d
}||| }n||}t|d| |d}||| t |jdksAJ dS )z:Test that positive Ridge finds true positive coefficients.rS   rH   r   rN   r   rz  r   r   rV   r   Trw   r  r}   r~   r   N)r?   r   r   r   r   ra   r   )r}   r~   rw   rm   r   r   rv   r   rE   rE   rF   #test_ridge_positive_regression_test  s   "
r9  c           
      C   s   t jd}|dd}|jdd|jd d}| r"d}|| | }n|| }||j|jd dd	 7 }g }d
D ]}t||| dd}	||		||j
 q7t|ddd dS )zTest that Ridge w/wo positive converges to the same solution.

    Ridge with positive=True and positive=False must give the same
    when the ground truth coefs are all positive.
    r   ,  r  r'  r   rS   r\   r   r   )TFr   )rw   r  r~   r   r  r.  N)r?   r_   r`   r   rb   r   rc   r   rk  r   r   r*   )
r~   rw   rl   rm   r   r   rv   r0  r  r   rE   rE   rF   %test_ridge_ground_truth_positive_test  s   r;  )r7   r9   r:   r8   r;   r<   c              	   C   s   d}t ddgddgg}t ddg}|| }t|d| dd	}tjtd
d ||| W d   n1 s8w   Y  tjtdd t|||d| dd\}}W d   dS 1 s\w   Y  dS )z5Test input validation for positive argument in Ridge.r'  rS   rH   r   rN   rT   TFr8  zdoes not support positiver   Nzonly 'lbfgs' solver can be used)r  r}   r  )r?   r   r   r   r   r   r   r   )r}   rw   rm   r   rv   r   rt   rE   rE   rF   test_ridge_positive_error_test	  s   "r<  c           	         s   t dddd\ dd}d fdd		}td
 }tdd }||}||}||ks7J t|D ]}|||d}||ksIJ q;dS )z?Check ridge loss consistency when positive argument is enabled.r:  r   rO   rP   rR   r'  r  Nr   c                    sp   | j }|d urtj|}| j|jd|| jjd }n| j}dt |  | d  d t|d   S )Nr   r\   r   rH   )r   r?   r_   r`   r   rb   r   r   )r   rR   noise_scaler   rl   r   rm   rw   rv   rE   rF   
ridge_loss$  s   &z,test_positive_ridge_loss.<locals>.ridge_lossr   T)rw   r  r3  )Nr   )r
   r   r   r
  )	rw   n_checksr@  r   model_positivelossloss_positiverR   loss_perturbedrE   r?  rF   test_positive_ridge_loss  s   rF  c                 C   sj   t dddd\}}t|d}t| g} dddd}t||| fi |}t||| }t||d	d
d dS )zETest that LBGFS gets almost the same coef of svd when positive=False.r:  r   r=  rS   FgؗҜ<i  )r  r   r   r  r   r.  N)r
   r?   expand_dimsr  r   r   r*   )rw   rm   rv   config
coef_lbfgsr   rE   rE   rF   test_lbfgs_solver_consistencyC  s   rJ  c                  C   sx   t ddgddgg} t ddg}tddddd	dd
}tjtdd || | W d   dS 1 s5w   Y  dS )z1Test that LBFGS solver raises ConvergenceWarning.rS   rT   g    _g    _Br   r  Fr   T)rw   r}   r~   r   r  r   zlbfgs solver did not converger   N)r?   r   r   r   r   r   r   )rm   rv   r   rE   rE   rF   test_lbfgs_solver_errorT  s   "rK  r  tallc                 C   s  |dur|dks|dv r| rt d tjd}d}|dkr$|d }n|d }|||}||}	|dur;||}t| d	||d
k|dd}
tdi |
j||	dd}|j	
 }| r^|j}t|	}|j||	|d t|j	|dd | r{t|j| |jdd|jd d}d|dd< |	dd  d9  < |j||	|d |j	
 }| r|j}|j|ddddf |	dd |dd d t|j	|dd | rt|j| tdi |
jtj|
d  d}|j||	tj| d |dv r| st d| d t|j	|dd | rt|j| |dur| }tj||d|d  gdd}t|	|	d|d  g}|
 }|d|d   d9  < tj||d|d  gdd}|dur\||}||}tdi |
j||	|d}tdi |
j|||d}t|j	|j	 | rt|j|j dS dS )zTest that the impact of sample_weight is consistent.

    Note that this test is stricter than the common test
    check_sample_weight_equivalence alone.
    Nr7   )r9   r<   zunsupported configurationr   rM   rL  rH   r   r  r   )r~   rw   r}   r  rR   r   r   r  rD  r   r   rX   r  rw   r   r   zSolver z- does fail test for scaling of sample_weight.r   rE   )r   r   r?   r_   r`   r  r   r   r   r   r  r   	ones_liker*   rb   r   rw  pir   toarrayr   )r~   r   r  r}   ri   rl   rO   rP   rm   rv   rL   r  r   r   r   r  X2y2sample_weight_1sample_weight_2r  rE   rE   rF   $test_ridge_sample_weight_consistencye  s   





0 

rU  r   c                 C   s   t dd|dd\}}tj|jd fd}| rd|ddd< d	}t|d
|dd}|j|||d tjg |jt|R d}t }	t	|D ]2\}
}t	|	
||D ]%\}\}}t||d}||| || ||  ||| ||d|
f< qPqDt|j| dS )ar  Check that the predictions stored in `cv_results_` are on the original scale.

    The GCV approach works on scaled data: centered by an offset and scaled by the
    square root of the sample weights. Thus, prior to computing scores, the
    predictions need to be scaled back to the original scale. These predictions are
    the ones stored in `cv_results_` in `RidgeCV`.

    In this test, we check that the internal predictions stored in `cv_results_` are
    equivalent to a naive LOO-CV grid search with a `Ridge` estimator.

    Non-regression test for:
    https://github.com/scikit-learn/scikit-learn/issues/13998
    r  rW   r   )rO   rP   r   rR   r   r   NrH   r  r@  T)r-  rC  r~   rT  r   r   .)r
   r?   r   r   r   r   emptyr   r   	enumeraterW  r   r   r*   rX  )r  r~   r   rm   rv   r   r-  rx  r_  rB  	alpha_idxrw   idx	train_idxtest_idxr   rE   rE   rF   !test_ridge_cv_results_predictions  s.   
r]  c                    s   t d| d\ tj jd fdtddd}|j d t }t|jd	t	 fd
d|
 D }t|jt|  dS )zCheck that `RidgeCV` works properly with multioutput and sample_weight
    when `scoring != None`.

    We check the error reported by the RidgeCV is close to a naive LOO-CV using a
    Ridge estimator.
    rH   r   rR   r   rV  r@  T)rC  rT  r   r   c                    s6   g | ]\}}j  | | | d  | qS )r   r   r   r   traintestrm   r   r   rv   rE   rF   r   	  s    z;test_ridge_cv_multioutput_sample_weight.<locals>.<listcomp>N)r
   r?   r   r   r   r   r   r   rE  squeezerW  r*   r  r   )ri   rx  rB  
y_pred_loorE   rc  rF   'test_ridge_cv_multioutput_sample_weight  s   rf  c                     s   t ddd\ dd fdd} t| d}|  t }t|jd	t fd
d| D }t	|j
|  dS )zECheck that `RidgeCV` works properly with a custom multioutput scorer.rH   r   r^  c                 S   s>   | | d }t j|dd}|jdkrt j|ddgd S | S )NrH   r   r   rS   )r   )r?   r@   ndimr  )y_truerC   errorsmean_errorsrE   rE   rF   custom_error	  s
   
z=test_ridge_cv_custom_multioutput_scorer.<locals>.custom_errorc                    s    ||  | S )zGMultioutput score that give twice more importance to the second target.)r   )r  rm   rv   )rk  rE   rF   custom_multioutput_scorer	  s   zJtest_ridge_cv_custom_multioutput_scorer.<locals>.custom_multioutput_scorer)rC  r   c                    s.   g | ]\}}  | |  | qS rE   r_  r`  )rm   r   rv   rE   rF   r   (	  s   . z;test_ridge_cv_custom_multioutput_scorer.<locals>.<listcomp>N)r
   r   r   r   r   rE  r?   rd  rW  r*   r  )rl  rx  rB  re  rE   )rm   rk  r   rv   rF   'test_ridge_cv_custom_multioutput_scorer	  s   

rm  metaestimator)enable_metadata_routingc                 C   s   |     dS )zTest that `RidgeCV` or `RidgeClassifierCV` with default `scoring`
    argument (`None`), don't enter into `RecursionError` when metadata is routed.
    N)get_metadata_routing)rn  rE   rE   rF   *test_metadata_routing_with_default_scoring2	  s   rq  zmetaestimator, make_datasetc                 C   s2   |dddd\}}| j ||t|jd d dS )zTest that `set_score_request` is set within `RidgeCV.fit()` and
    `RidgeClassifierCV.fit()` when using the default scoring and no
    UnsetMetadataPassedError is raised. Regression test for the fix in PR #29634.r  r   r   r=  r   r   N)r   r?   r   r   )rn  r}  rm   rv   rE   rE   rF   +test_set_score_request_with_default_scoring;	  s    rr  )r  r  r   rW   rS   r  r  r  TFFN)r  	itertoolsr   numpyr?   r   scipyr   sklearnr   r   sklearn.baser   sklearn.datasetsr   r   r	   r
   sklearn.exceptionsr   sklearn.linear_modelr   r   r   r   r   r   sklearn.linear_model._ridger   r   r   r   r   r   r   sklearn.metricsr   r   r   sklearn.model_selectionr   r   r   r   r    sklearn.preprocessingr!   sklearn.utilsr"   sklearn.utils._array_apir#   r$   r%   r&   r'   r(   -sklearn.utils._test_common.instance_generatorr)   sklearn.utils._testingr*   r+   r,   r-   r.   sklearn.utils.estimator_checksr/   r0   sklearn.utils.fixesr1   r2   r3   r4   r5   r6   SOLVERSr   r   load_diabetesdiabetesr  r   r   r   r   r   indr_   r`   rl   r  	load_irisr  r  r  rG   rI   fixturer|   markparametrizer   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r#  r4  r  rJ  rL  ra  rf  ru  ry  r~  r  r  r  r  r  r  r  r  r  r  r  sortedr  r  r  r  r  r  r  r  r  r  r  r  r  r   	TypeErrorr  r  r  r  r  r  r  r  r   r   r  r+  r-  r
  r2  r5  r7  r9  r;  r<  rF  rJ  rK  rU  r]  rf  rm  rq  rr  rE   rE   rE   rF   <module>   sf    $	  	

F,&(5552	 -.' 	>	
9
	G#


*

#




'	


&	7
" 





%
_+"

