
    >[g6L              	       r   d Z ddlZddlZddlZddlmZmZ ddlm	Z	 ddl
mZ ddlmZmZmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ  ed      Z e       Zej=                  ej>                  j@                        Z!ejD                  e!   Z#ej>                  e!   Z$de#jJ                  _&        de$jJ                  _&         ejN                  e(      jR                  Z*d Z+d Z,d Z-d Z.d Z/d Z0d Z1ejd                  jg                  dg d      ejd                  jg                  dg d      ejd                  jg                  dg d      ejd                  jg                  dg d      d                             Z4d Z5d Z6ejd                  jg                  dg d      d         Z7d! Z8d" Z9d# Z:d$ Z;d% Z<d& Z=ejd                  jg                  d'd ej|                  d(      fd) ej|                  d*      fd+ ej~                  d,      fg      d-        Z@ejd                  jg                  ddd.g      d/        ZAy)0zL
Testing for Neighborhood Component Analysis module (sklearn.neighbors.nca)
    N)assert_array_almost_equalassert_array_equal)
check_grad)clone)	load_iris
make_blobsmake_classification)ConvergenceWarning)pairwise_distances)NeighborhoodComponentsAnalysis)LabelEncoder)check_random_state)validate_dataFc                  T   t        j                  ddgddgddgddgg      } t        j                  g d      }t        ddd      }|j                  | |       |j	                  |       }t        t        |      j                         dddf   t        j                  g d	             y)
zTest on a simple example.

    Puts four points in the input space where the opposite labels points are
    next to each other. After transform the samples from the same class
    should be next to each other.

    r         )r   r   r   r   identity*   )n_componentsinitrandom_stateN)r      r   r   )nparrayr   fit	transformr   r   argsort)XyncaX_ts       [/var/www/html/bid-api/venv/lib/python3.12/site-packages/sklearn/neighbors/tests/test_nca.pytest_simple_exampler#   $   s     	1a&1a&1a&1a&12A
A
(ZbC GGAqM
--
C)#.668A>@VW    c                     t         j                  j                  d      } d}| j                  d|      }t        j                  ||j                  d      t         j                  ddf   g      }g d} G d d	      } |||      }t        d|j                  
      }|j                  ||      }t        |       t        ||d   z
  d       t        |j                  dz         dk  sJ y)a  Test on a toy example of three points that should collapse

    We build a simple example: two points from the same class and a point from
    a different class in the middle of them. On this simple example, the new
    (transformed) points should all collapse into one single point. Indeed, the
    objective is 2/(1 + exp(d/2)), with d the euclidean distance between the
    two samples from the same class. This is maximized for d=0 (because d>=0),
    with an objective equal to 1 (loss=-1.).

    r      r   r   )axisN)r   r   r   c                       e Zd Zd Zd Zy)4test_toy_example_collapse_points.<locals>.LossStorerc                 f   t         j                  | _        t               | _        t         j                  | j                  _        t        | j                  ||d      \  | _        }t               j                  |      }|d d t         j                  f   |t         j                  d d f   k(  | _        y Nr   )ensure_min_samples)r   inflossr   fake_ncan_iter_r   r   r   fit_transformnewaxissame_class_maskselfr   r   s      r"   __init__z=test_toy_example_collapse_points.<locals>.LossStorer.__init__H   sz    DI:<DM$&FFDMM!%dmmQaPIDFA,,Q/A#$Q

]#3qQ7G#GD r$   c                 x    | j                   j                  || j                  | j                  d      \  | _        }y)z*Stores the last value of the loss functiong      N)r/   _loss_grad_lbfgsr   r3   r.   )r5   transformationn_iter_s       r"   callbackz=test_toy_example_collapse_points.<locals>.LossStorer.callbackQ   s/    ==99(<(<dLDIqr$   N__name__
__module____qualname__r6   r<    r$   r"   
LossStorerr)   G   s    	H	r$   rB   )r   r<           r   g|=)r   randomRandomStaterandnvstackmeanr2   r   r<   r1   printr   absr.   )	rng	input_dim
two_pointsr   r   rB   loss_storerr    r!   s	            r"    test_toy_example_collapse_pointsrO   6   s     ))


#CI1i(J
		:zA6rzz1}EFGAA   Q"K
(b;CWCW
XC


Aq
!C	#JcCFlC0{!#$u,,,r$   c                   	 t         j                  j                  |       }t        |       \  }|j	                  |j                  dj                  d   dz         j                  d         }t               	d	_        |ddt         j                  f   |t         j                  ddf   k(  	fd}	fd}t        |||j                               }|t        j                  dd	      k(  sJ y)
z~Test gradient of loss function

    Assert that the gradient is almost equal to its finite differences
    approximation.
    )r   r   r   Nc                 0    j                  |       d   S )Nr   r8   Mr   maskr    s    r"   funz$test_finite_differences.<locals>.funn       ##Aq$/22r$   c                 0    j                  |       d   S )Nr   rR   rS   s    r"   gradz%test_finite_differences.<locals>.gradq   rW   r$   rC   -C6?)rJ   )r   rD   rE   r	   rF   randintshaper   r0   r2   r   ravelpytestapprox)
global_random_seedrK   r   rT   rV   rY   diffr   rU   r    s
          @@@r"   test_finite_differencesrb   `   s     ))

 2
3C,>?DAq		#++aa0!''!*=A
(
*CCKQ

]qQ//D33 c4+D6==$////r$   c                     t        j                  d      j                  dd      } g d}t        }t         j                  j                  d      }|j                  dd      }d|j                  d    d	|j                  d
    d}t        j                  t        t        j                  |            5   ||      j                  | |       d d d        d}d| d| j                  d
    d}t        j                  t        t        j                  |            5   ||      j                  | |       d d d        y # 1 sw Y   rxY w# 1 sw Y   y xY w)N      r   r   r   r   r   r   r&   The output dimensionality (r   ]) of the given linear transformation `init` cannot be greater than its input dimensionality (r   ).matchr   
   DThe preferred dimensionality of the projected space `n_components` (8) cannot be greater than the given data dimensionality ()!r   )r   arangereshaper   rD   rE   randr\   r^   raises
ValueErrorreescaper   )r   r   NCArK   r   msgr   s          r"   test_params_validationr{   y   s   
		"a#AA
(C
))


#C88Aq>D
%djjm_ 5226**Q-	D 
 
z3	81a  
9L	'. )//0wwqzl"	> 
 
z3	8&**1a0 
9	8 
9	8 
9	8s   2D=E	=E	Ec                  r   t        j                  d      j                  dd      } g d}t        j                  ddgddgg      }t	        j
                  t              5  t        |      j                  | |       d d d        t        j                  ddgddgdd	gg      }t	        j
                  t              5  t        |      j                  | |       d d d        t        j                  d
      j                  dd      }t        |      j                  | |       y # 1 sw Y   xY w# 1 sw Y   WxY w)Nrd   re   r   rf   r   r   rl   r&      	   )	r   rr   rs   r   r^   ru   rv   r   r   )r   r   r9   s      r"   test_transformation_dimensionsr      s    
		"a#AA XX1v1v./N	z	"&N;??1E 
#
 XX1v1v1v67N	z	"&N;??1E 
# YYq\))!Q/N"7;;AqA 
#	" 
#	"s   D!:D-!D*-D6c                  8   t         j                  j                  d      } t        j                  d      j	                  dd      }g d}| j                  |j                  d   dz
  d      }|j                  d   }t        ||      }d| d	|j                  d
    d}t        j                  t        t        j                  |            5  |j                  ||       d d d        |j                  d   dz   }t        ||      }d| d|j                  d    d}t        j                  t        t        j                  |            5  |j                  ||       d d d        t        dd      }|j                  ||       y # 1 sw Y   xY w# 1 sw Y   5xY w)Nr   rd   re   r   rf   r   r   r   rn   V) does not match the output dimensionality of the given linear transformation `init` (r   rp   rj   r   ro   r   )r   r   )r   rD   rE   rr   rs   rt   r\   r   r^   ru   rv   rw   rx   r   )rK   r   r   r   r   r    rz   s          r"   test_n_componentsr      s\   
))


#C
		"a#AA88AGGAJNA&D 771:L
(d
NC	'. )::a=/	%  
z3	81 
9 771:>L
(d
NC	'. )**+''!*R	9 
 
z3	81 
9 )aj
ICGGAqM! 
9	8 
9	8s   F	FFFc                  `   t         j                  j                  d      } t        dddd      \  }}t	        d      }|j                  ||       t	        d	      }|j                  ||       t	        d
      }|j                  ||       t	        d      }|j                  ||       t	        d      }|j                  ||       | j                  |j                  d   |j                  d         }t	        |      }|j                  ||       | j                  |j                  d   |j                  d   dz         }t	        |      }d|j                  d    d|j                  d    d}	t        j                  t        t        j                  |	            5  |j                  ||       d d d        | j                  |j                  d   dz   |j                  d         }t	        |      }d|j                  d    d|j                  d    d}	t        j                  t        t        j                  |	            5  |j                  ||       d d d        | j                  |j                  d   |j                  d         }|j                  d   dz
  }
t	        ||
      }d|
 d|j                  d    d}	t        j                  t        t        j                  |	            5  |j                  ||       d d d        y # 1 sw Y   \xY w# 1 sw Y   xY w# 1 sw Y   y xY w)Nr      r}   r&   r   	n_samplescenters
n_featuresr   r   rl   rD   autopcaldar   zThe input dimensionality (zc) of the given linear transformation `init` must match the dimensionality of the given inputs `X` (ri   rj   rg   rh   r   r   rn   r   rp   )r   rD   rE   r   r   r   rt   r\   r^   ru   rv   rw   rx   )rK   r   r   r    
nca_randomnca_autonca_pcanca_ldar   rz   r   s              r"   test_init_transformationr      s   
))


#CA!!LDAq )j
9CGGAqM 0X>JNN1a .6:HLLA -%8GKK1 -%8GKK188AGGAJ
+D
(d
3CGGAqM 88AGGAJ
Q/D
(d
3C
$TZZ]O 4334771:,b	B 
 
z3	81 
9 88AGGAJNAGGAJ/D
(d
3C
%djjm_ 5226**Q-	D 
 
z3	81 
9 88AGGAJ
+D771:>L
(d
NC	++7. 9))-Ar	;  
z3	81 
9	81 
9	8 
9	8 
9	8s$   LL/L$LL!$L-r   )r   r&         r   	n_classes)r&   r   r   r   c                 r   t         j                  j                  d      }t        d|d|      }|| k\  ry |j	                  | |      }t        j
                  t        |      | |z  dz         d |  }||kD  ry t        |      }|j                  ||       |t        |dz
  |      k  rt        |      j                  d      }	nF|t        ||       k  rt        |      j                  d      }	nt        |      j                  d      }	|	j                  ||       t        |j                  |	j                         y )	Nr   r   r   )r   r   max_iterr   r   rl   r   r   )r   rD   rE   r   rF   tileranger   r   min
set_paramsr   components_)
r   r   r   r   rK   nca_baser   r   r    	nca_others
             r"   test_auto_initr   
  s    ))


#C-,H I IIi,GGE)$i9&<q&@A*9M*$ /CGGAqMs9q=*==!(O66E6B	J	 ::!(O66E6B	!(O66J6G	MM!Q%cooy7L7LMr$   c                     t        dddddd      \  } }t        dd      }|j                  | |       t        dddddd      \  }}d|j                  d	    d
|j                  j                  d	    d}t        j                  t        t        j                  |            5  |j                  ||       d d d        y # 1 sw Y   y xY w)Nr   r&   re   r   )r   r   r   n_redundantn_informativer   T)
warm_startr   zThe new inputs dimensionality (r   zT) does not match the input dimensionality of the previously learned transformation (ri   rj   )
r	   r   r   r\   r   r^   ru   rv   rw   rx   )r   r   r    X_less_featuresrz   s        r"   test_warm_start_validationr   -  s    DAq )D1
ECGGAqM,OQ */*?*?*B)C D??0034B	8 
 
z3	8# 
9	8	8s   #B??Cc                  `   t        dd      } | j                  t        t               | j                  }d| _        | j                  t        t               | j                  }t        dd      }|j                  t        t               |j                  }d|_        |j                  t        t               |j                  }t        j                  t        j                  ||z
              }t        j                  t        j                  ||z
              }|dk  sJ d       ||kD  sJ d       y )	NTr   )r   r   r   Fg      @zVTransformer changed significantly after one iteration even though it was warm-started.zfCold-started transformer changed less significantly than warm-started transformer after one iteration.)	r   r   	iris_datairis_targetr   r   r   sumrJ   )nca_warmtransformation_warmtransformation_warm_plus_onenca_coldtransformation_coldtransformation_cold_plus_one	diff_warm	diff_colds           r"   test_warm_start_effectivenessr   K  s    .ANHLLK("..HLLK(#+#7#7 -QOHLLK("..HLLK(#+#7#7 rvv:=PPQRIrvv:=PPQRIs? 	5?
 y  	+ r$   	init_name)r   r   r   rD   precomputedc                 
   t         j                  j                  d      }t        dddd      \  }}d}d|z   d	|z   d
}| dk(  r-|j	                  |j
                  d   |j
                  d         }n| }t        d|      }|j                  ||       |j                         \  }	}
t        j                  d|	      }| d
v r#t        j                  ||    |d         sJ |dd  }|d   dk(  sJ dj                  ddd      }|d   dj                  |      k(  sJ |d   dj                  dt        |      z        k(  sJ |dd D ]  }t        j                  d|      rJ  t        j                  d|d         sJ |d   dk(  sJ y )Nr   r   r}   r&   r   r   z... done in \ *\d+\.\d{2}szFinding principal componentsz&Finding most discriminative components)r   r   r   r   )verboser   z
+z [NeighborhoodComponentsAnalysis]z{:>10} {:>20} {:>10}	IterationzObjective ValuezTime(s)z#[NeighborhoodComponentsAnalysis] {}r   -r   zH\[NeighborhoodComponentsAnalysis\] *\d+ *\d\.\d{6}e[+|-]\d+\ *\d+\.\d{2}z@\[NeighborhoodComponentsAnalysis\] Training took\ *\d+\.\d{2}s\. )r   rD   rE   r   rF   r\   r   r   
readouterrrw   splitrk   formatlen)r   capsysrK   r   r   regexp_initmsgsr   r    outr;   linesheaderlines                 r"   test_verboser   k  s    ))


#CA!!LDAq/K-;7+ED M!yyQWWQZ0
(
>CGGAqM FC HHUC E N"xxYq222ab	89999#**;8I9UF8<CCFKKKK8<CCC#f+DUVVVVa xx%
 	
 
  88Ob	   9??r$   c                     t               }|j                  t        t               | j	                         \  }}|dk(  sJ y )Nr   )r   r   r   r   r   )r   r    r   r;   s       r"   test_no_verboser     s6    
(
*CGGI{# FC"99r$   c                     t         j                         } t        j                         }d}t        j                  ||k(        \  }d||<   |||d   <   t        d      }|j                  | |       t        j                  |dk(        \  }t        j                  |dk(        \  }d||<   d||d   <   d||<   d||d   <   t        d      }|j                  | |       t        j                  |dk(        \  }t        j                  |dk(        \  }t        j                  |dk(        \  }| |d   |d   |d   g   } ||d   |d   |d   g   }t        dd      }|j                  | |       t        | |j                  |              y )Nr   r   r   r   )r   r   )r   r   )	r   copyr   r   wherer   r   r   r   )r   r   singleton_classind_singletonr    ind_1ind_2ind_0s           r"   test_singleton_classr     sz   AA Oxx_ 45]Am)AmA
("
5CGGAqM xxQHUxxQHUAeHAeAhKAeHAeAhK
("
5CGGAqM xxQHUxxQHUxxQHU	58U1XuQx
()A	58U1XuQx
()A
(j2
FCGGAqMq#--*+r$   c                      t         t        dk(     } t        t        dk(     }t        d| j                  d   d      }|j	                  | |       t        | |j                  |              y )Nr   r   r   r   )r   r   r   )r   r   r   r\   r   r   r   )r   r   r    s      r"   test_one_classr     s[    +"#AK1$%A
(!''!*:C GGAqMq#--*+r$   c                     dfd}t        |d      }|j                  t        t               | j	                         \  }}dj                  dz
        |v sJ y )Nrm   c                     | j                   t        j                   d   dz  fk(  sJ |z
  }t        dj                  |             y )Nr   r   {} iterations remaining...)r\   r   rI   r   )r9   r:   rem_iterr   s      r"   my_cbztest_callback.<locals>.my_cb  sF    ##	(:a(?'AAAAf$*11(;<r$   r   )r   r<   r   r   )r   r   r   r   r   r   )r   r   r    r   r;   r   s        @r"   test_callbackr     s]    H= )(UTU
VCGGI{# FC (..x!|<CCCr$   c                      t         } t        } G d d      } || |      }|j                  }t        d|      }|j	                  | |       |j
                  j                  | j                  d   dz  k(  sJ y)z4Test that the transformation has the expected shape.c                       e Zd Zd Zd Zy)@test_expected_transformation_shape.<locals>.TransformationStorerc                 <   t               | _        t        j                  | j                  _        t        | j                  ||d      \  | _        }t               j                  |      }|d d t        j                  f   |t        j                  d d f   k(  | _
        y r+   )r   r/   r   r-   r0   r   r   r   r1   r2   r3   r4   s      r"   r6   zItest_expected_transformation_shape.<locals>.TransformationStorer.__init__  sq     ;<DM$&FFDMM!%dmmQaPIDFA,,Q/A#$Q

]#3qQ7G#GD r$   c                     || _         y)zWStores the last value of the transformation taken as input by
            the optimizerN)r9   )r5   r9   r:   s      r"   r<   zItest_expected_transformation_shape.<locals>.TransformationStorer.callback  s     #1Dr$   Nr=   rA   r$   r"   TransformationStorerr     s    	H	1r$   r   r&   )r   r<   r   r   N)r   r   r<   r   r   r9   sizer\   )r   r   r   transformation_storercbr    s         r"   "test_expected_transformation_shaper     so    AA1 1 1A6		'	'B
(!b
ACGGAqM //44
aGGGr$   c                  &   t        dd      } | j                  j                  }dj                  |      }t	        j
                  t        t        j                  |            5  | j                  t        t               d d d        y # 1 sw Y   y xY w)Nr   r   )r   r   z[{}] NCA did not convergerj   )r   	__class__r>   r   r^   warnsr
   rw   rx   r   r   r   )r    cls_namerz   s      r"   test_convergence_warningr     s_    
(!Q
?C}}%%H
%
,
,X
6C	(		#	?	;' 
@	?	?s   #BBzparam, valuer   r   d   tolrZ   c                 Z    t        di | |i}t        }t        }|j                  ||       y )NrA   )r   r   r   r   )paramvaluer    r   r   s        r"   test_parameters_valid_typesr     s,     )
:E5>
:CAAGGAqMr$   r   c                 r   t         }t        }t        |       j                  ||      }|j	                         }|j
                  j                  j                         }| | }n|j                  d   }t        j                  t        |      D cg c]  }| | 
 c}t              }t        ||       yc c}w )zCheck `get_feature_names_out` for `NeighborhoodComponentsAnalysis`.

    Non-regression test for:
    https://github.com/scikit-learn/scikit-learn/issues/28293
    rq   Nr   )dtype)r   r   r   r   get_feature_names_outr   r>   lowerr\   r   r   r   objectr   )	r   r   r   est	names_outclass_name_lowerexpected_n_featuresiexpected_names_outs	            r"   test_nca_feature_names_outr     s     	AA
(l
C
G
G1
MC))+I}}--335*ggaj+01D+EF+EaaS	!+EF
 y"45	 	Gs   B4)B__doc__rw   numpyr   r^   numpy.testingr   r   scipy.optimizer   sklearnr   sklearn.datasetsr   r   r	   sklearn.exceptionsr
   sklearn.metricsr   sklearn.neighborsr   sklearn.preprocessingr   sklearn.utilsr   sklearn.utils.validationr   rK   irispermutationtargetr   permdatar   r   flags	writeablefinfofloatepsEPSr#   rO   rb   r{   r   r   r   markparametrizer   r   r   r   r   r   r   r   r   r   int32float32r   r   rA   r$   r"   <module>r     s$   
   G %  G G 1 . < . , 2{
t{{''(IIdO	kk$!	 #   bhhuoX$'-T0212B* F=@ m4}5j17N 8 2 6 5N>$<@ D))X!,H,D"H6( 	!%	XRXXc]#	


6"# $36 46r$   