o {i8}@s^ ddlmZddlZddlZddlZddlmZm Z m Z m Z m Z ddl mZmZddlZddlmZdZeejjdZeejjdZedgd ZejdddZejdddddfZejdddZ ejZ!e"ed ed fZ#ejdddZ$ej%d d e&d DejdZ'ej(ej)*ejdddejdddee!fejdddddfejdddej+dddej,ej,ejdddejejej,ej,ej,ej,d ddddddZ-ej(ej)*ejdddejddde e!fejdddddfejdddej+dddej,ej,ejdddejejej,ej,ej,ej,d ddddddZ.ej(ej)*ejdddejdddee!fejdddddfejdddej+dddej,ej,ejdddejejej,ej,ej,ej,d ddddddZ/ej(dddej)jdddej)jdddej)jej)j,ddddZ0ej(ddddddZ1dZ2ej(ddd dd!d"Z3ej(ddd dd#d$Z4ej(ddd ddd&d'Z5d(Z6ej(ddd dd)d*Z7ej(ddd dd+d,Z8ej(dd ej)jej)jd-d. / 0dd1d2Z9ej(dd ej)jej)jd-d. / 0dd3d4Z:ej(dd d5 / 0dd6d7Z;ej(ddd dd8d9Zej(dd ej)jej)jd-d. / 0dd>d?Z?ej(dd d5 / 0dd@dAZ@ej(ddd dddCdDZAej(ddd ddEdFZBej(dd ej)jej)jd-d. / 0ddGdHZCej(dd d5 / 0ddIdJZDej(dej)jej)jd-dK / 0ddLdMZEej(dej)Fe#ej)jej)jdNdK / 0ddOdPZGej(dej)Fe#ej)jej)jdNdK / 0ddQdRZHej(dej)jej)jd-dK / 0ddSdTZIej(dej)jej)jd-dK / 0ddUdVZJej(ddWddXdYZKej(ddW / 0ddZd[ZLej(ddWdd\d]ZMej(d^ej)Nej)jOej)jdd_dd`ej)jej)jOej)jdd_dd`ej)jOej)j+dd_d d`gdej)jej)jPej)jQdaddbdcddZRej(deej)Nej)jOej)jdd_dd`ej)jej)jOej)jdd_dd`ej)jOej)j+dd_d d`gdej)jej)jPej)jQdaddbdfdgZSej(dhej)jOej)jdd_dd`ej)jOej)jdd_dd`ej)jOej)jdid_dd`ej)jOej)jdd_dd`ej)jOej)jdid_dd`ej)jOej)jdd_dd`ej)jOej)j+dd_d d`gej)j,ej)jNdjddkdldmZTej(dnej)jOej)jdd_dd`ej)jOej)jdd_dd`ej)jOej)jdid_dd`ej)jOej)jdd_dd`ej)jOej)jdid_dd`ej)jOej)jdd_dd`ej)jOej)j+dd_d d`gej)j,ej)jNdjddkdodpZUej(dddqdrdsZVej(dtej)j,iddkdudvZW  0ddwdxZXej(ddWdydzZYd{d|ZZd}d~Z[ddZ\e(ddZ]ej(ddddZ^ddZ_dZ`dZadiZbdBZcdZdddZeddZfej(dej+dddejej,dd dddZgej(dejejdd dddZhdS))warnN) sparse_mul sparse_diff sparse_sum arr_intersectsparse_dot_product) tau_rand_intnorm) namedtupleg:0yE>FlatTree hyperplanesoffsetschildrenindices leaf_sizecCsg|] }t|dqS)1)bincount.0irH/home/ubuntu/.local/lib/python3.10/site-packages/pynndescent/rp_trees.py &srdtype) n_leftn_righthyperplane_vectorhyperplane_offsetmargindr left_index right_indexT)localsfastmathnogilcachecCs|jd}t||jd}t||jd}|||k7}||jd}||}||}t||}t||} t|tkr@d}t| tkrHd} tj|tjd} t|D]} ||| f|||| f| | | <qTt| } t| tkrud} t|D] } | | | | | <qyd} d}t|jdtj }t|jdD]L}d}t|D]} || | |||| f7}qt|tkrt|d||<||dkr| d7} q|d7}q|dkrd||<| d7} qd||<|d7}q| dks|dkrd} d}t|jdD]}t|d||<||dkr| d7} q|d7}qtj| tj d}tj|tj d}d} d}t|jdD] }||dkrE|||| <| d7} q0||||<|d7}q0||| dfS)MGiven a set of ``graph_indices`` for graph_data points from ``graph_data``, create a random hyperplane to split the graph_data, returning two arrays graph_indices that fall on either side of the hyperplane. This is the basis for a random projection tree, which simply uses this splitting recursively. This particular split uses cosine distance to determine the hyperplane and which side each graph_data sample falls on. Parameters ---------- data: array of shape (n_samples, n_features) The original graph_data to be split indices: array of shape (tree_node_size,) The graph_indices of the elements in the ``graph_data`` array that are to be split in the current operation. rng_state: array of int64, shape (3,) The internal state of the rng Returns ------- indices_left: array The elements of ``graph_indices`` that fall on the "left" side of the random hyperplane. indices_right: array The elements of ``graph_indices`` that fall on the "left" side of the random hyperplane. r r?r) shaperr absEPSnpemptyfloat32rangeint8int32)datar rng_statedimr&r'leftright left_norm right_normr"r%hyperplane_normr r!siderr$ indices_left indices_rightrrrangular_random_projection_split)sv ,                       rDcCs|jd}t||jd}t||jd}|||k7}||jd}||}||}d}d} tj|dtjd} | d|} | |d} t|D]"} ||| f||| fA}|||| f@| | <|||| f@| | <qJd}t|D]} |t| | 7}|t||| f7}| t||| f7} qsd}d}t|jdtj}t|jdD]^}d}t|D]"} |t| | |||| f@7}|t| | |||| f@8}qt|t krt|d||<||dkr|d7}q|d7}q|dkrd||<|d7}qd||<|d7}q|dks|dkr8d}d}t|jdD]}t|d||<||dkr2|d7}q|d7}qtj|tj d}tj|tj d}d}d}t|jdD] }||dkrh||||<|d7}qS||||<|d7}qS||| dfS)r,r rr.r/rN) r0rr3r4uint8r6popcntr7r1r2r8)r9rr:r;r&r'r<r=r>r?r"positive_hyperplane_componentnegative_hyperplane_componentr% xor_vectorr@r r!rArr$rBrCrrr)angular_bitpacked_random_projection_splitst ,       "             rJcCsd|jd}t||jd}t||jd}|||k7}||jd}||}||}d}tj|tjd} t|D]$} ||| f||| f| | <|| | ||| f||| fd8}q:d} d} t|jdtj} t|jdD]N}|}t|D]} || | |||| f7}q|t|tkrtt|d| |<| |dkr| d7} qt| d7} qt|dkrd| |<| d7} qtd| |<| d7} qt| dks| dkrd} d} t|jdD]}t|d| |<| |dkr| d7} q| d7} qtj| tj d}tj| tj d}d} d} t| jdD] }| |dkr |||| <| d7} q |||| <| d7} q ||| |fS)aPGiven a set of ``graph_indices`` for graph_data points from ``graph_data``, create a random hyperplane to split the graph_data, returning two arrays graph_indices that fall on either side of the hyperplane. This is the basis for a random projection tree, which simply uses this splitting recursively. This particular split uses euclidean distance to determine the hyperplane and which side each graph_data sample falls on. Parameters ---------- data: array of shape (n_samples, n_features) The original graph_data to be split indices: array of shape (tree_node_size,) The graph_indices of the elements in the ``graph_data`` array that are to be split in the current operation. rng_state: array of int64, shape (3,) The internal state of the rng Returns ------- indices_left: array The elements of ``graph_indices`` that fall on the "left" side of the random hyperplane. indices_right: array The elements of ``graph_indices`` that fall on the "left" side of the random hyperplane. r rr.r@r/) r0rr3r4r5r6r7r1r2r8)r9rr:r;r&r'r<r=r#r"r%r r!rArr$rBrCrrr!euclidean_random_projection_split0sd ,  "               rL)normalized_left_datanormalized_right_datar@r)r)r*r+r(c"CsFt||jd}t||jd}|||k7}||jd}||}||}|||||d} |||||d} |||||d} |||||d} t| } t| }t| tkrgd} t|tkrod}| | tj}| |tj}t| || |\}}t|}t|tkrd}t |jdD] }|||||<qd}d}t |jdtj }t |jdD]l}d}|||||||d}|||||||d}t ||||\}}|D]}||7}qt|tkrt|d||<||dkr |d7}q|d7}q|dkrd||<|d7}qd||<|d7}q|dks2|dkrZd}d}t |jdD]}t|d||<||dkrT|d7}q=|d7}q=tj |tj d}tj |tj d} d}d}t |jdD] }||dkr||||<|d7}qu||| |<|d7}qut||f}!|| |!dfS)Given a set of ``graph_indices`` for graph_data points from a sparse graph_data set presented in csr sparse format as inds, graph_indptr and graph_data, create a random hyperplane to split the graph_data, returning two arrays graph_indices that fall on either side of the hyperplane. This is the basis for a random projection tree, which simply uses this splitting recursively. This particular split uses cosine distance to determine the hyperplane and which side each graph_data sample falls on. Parameters ---------- inds: array CSR format index array of the matrix indptr: array CSR format index pointer array of the matrix data: array CSR format graph_data array of the matrix indices: array of shape (tree_node_size,) The graph_indices of the elements in the ``graph_data`` array that are to be split in the current operation. rng_state: array of int64, shape (3,) The internal state of the rng Returns ------- indices_left: array The elements of ``graph_indices`` that fall on the "left" side of the random hyperplane. indices_right: array The elements of ``graph_indices`` that fall on the "left" side of the random hyperplane. rr r-r.r/r)rr0r r1r2astyper3r5rr6r4r7rr8vstack)"indsindptrr9rr:r&r'r<r= left_inds left_data right_inds right_datar>r?rMrNhyperplane_indshyperplane_datar@r%r r!rArr$i_indsi_data_mul_datavalrBrC hyperplanerrr&sparse_angular_random_projection_splits*                   r`)r)r*r+cCstt||jd}tt||jd}|||k7}||jd}||}||}|||||d} |||||d} |||||d} |||||d} d} t| | | | \}}t| | | | \}}|d}t||||tj\}}|D]}| |8} qd}d}t |jdtj }t |jdD]l}| }|||||||d}|||||||d}t||||\}}|D]}||7}qt|t krtt|d||<||dkr|d7}q|d7}q|dkrd||<|d7}qd||<|d7}q|dks|dkrAd}d}t |jdD]}tt|d||<||dkr;|d7}q"|d7}q"tj |tj d}tj |tj d}d}d}t |jdD] }||dkrq||||<|d7}q\||||<|d7}q\t||f}|||| fS)rOrr r.rKr/r)r3r1rr0rrrrPr5r4r7r6r2r8rQ)rRrSr9rr:r&r'r<r=rTrUrVrWr#rXrY offset_inds offset_datar^r r!rArr$rZr[r\r]rBrCr_rrr(sparse_euclidean_random_projection_split1sz                    rciFcCs`d}|jdd}||kr.||d}|||kr|S|||kr&|d}n|d}||ks dS)z5Binary search returning index if found, -1 otherwise.rr r/r)r0) sorted_arrvaluelohimidrrr binary_searchs    ricCsl|jd}tj|tjd}t|D]"}t|jdD]}|||f}|dkr2||kr2||d7<qq|S)aCompute global in-degree for all points in the graph. In-degree of a point is how many times it appears as a neighbor of other points. This is computed once and reused throughout tree construction. Parameters ---------- neighbor_indices : array of shape (n_samples, n_neighbors) The neighbor graph indices. Returns ------- global_degrees : array of shape (n_samples,) The in-degree of each point. rrr )r0r3zerosr8r6)neighbor_indicesn_pointsglobal_degreesrjneighborrrrcompute_global_degreess   rpc Cs|jd}t||}tj|tdtjd}tj|tjd}t|D]U}|||}|||dkrw|d} | dkrR||| dkrR| d8} | dkrR||| dksBt|d| dD]} || d|| <|| d|| <qZ||| <|||| <q"|S)a.Get the indices of the top k highest-degree points from a subset. Uses an efficient O(n) selection for small k by maintaining a min-heap of k elements. Parameters ---------- indices : array of shape (n,) The point indices in the current split. global_degrees : array of shape (n_total,) Precomputed global degrees for all points. k : int Number of top hubs to return. Returns ------- top_hubs : array of shape (min(k, n),) The actual point indices (not positions) of the top k hubs. rrrr r0minr3fullr8r4r6) rrmkrlactual_k top_degrees top_indicesrdeg insert_posrnrrrget_top_k_hub_indicess$     r{g?c CsJ|jd}|jd}t||d}|jd}td} td} td} tj|tjd} td} tj|tjd}tj|tjd}t|D]}t|d|D]}||}||}td}tj|tjd}t|D]$}|||f|||f||<||||||f|||fd8}qitd}td}t|D]I}|}t|D]}|||||||f7}q|t krd||<|d7}q|t krd||<|d7}q|d||<||dkr|d7}q|d7}q|dks|dkrqNtt ||t|}|| kr%|} |} |} |} t|D] }||| |<q t|D] }||||<qqNqE| dks1| dkr_td} td} t|D]}t t |d||<||dkrY| d7} q?| d7} q?tj| tj d}tj| tj d}td}td}t|D] }||dkr||||<|d7}q}||||<|d7}q}||| | | fS)aHub-based graph-informed split using balance-based selection. Uses the top 3 highest-degree nodes to generate all 3 possible hyperplanes, then selects the one with the best balance (closest to 50/50 split). This is much faster than edge-cut counting while still producing good quality trees. Parameters ---------- data : array of shape (n_samples, n_features) The data array. indices : array of shape (n,) Indices of points in this node. neighbor_indices : array of shape (n_samples, n_neighbors) The neighbor graph. global_degrees : array of shape (n_samples,) Precomputed global in-degrees. rng_state : array of int64, shape (3,) RNG state (only used for fallback). Returns ------- indices_left, indices_right, hyperplane, offset, balance The balance is returned so the caller can decide whether to accept the split. r rr.rrKr/)r0r{r3r5uint32rjr7r4r6r2rsr1rr8)r9rrkrmr:r;rltop_hubsn_hubs best_balance best_n_left best_n_rightbest_hyperplane best_offset best_siderArghjr<r=r#r"r%r r!rr$balancerBrCrrreuclidean_hub_split!s           "              6            rc Cs|jd}|jd}t||d}|jd}td} td} td} tj|tjd} tj|tjd} tj|tjd}t|D]}t|d|D]}||}||}t ||}t ||}t |t krhd}t |t krpd}tj|tjd}t|D]}|||f||||f|||<q|t |}t |t krd}t|D] }|||||<qtd}td}t|D]M}td}t|D]}|||||||f7}q|t krd||<|d7}q|t krd||<|d7}q|d||<||dkr|d7}q|d7}q|dks|dkrqJtt ||t|}|| krG|} |} |} t|D] }||| |<q/t|D] }||| |<q=qJq@| dksS| dkrtd} td} t|D]}t t |d| |<| |dkr{| d7} qa| d7} qatj| tjd}tj| tjd}td}td}t|D] }| |dkr||||<|d7}q||||<|d7}q||| td| fS)aAngular hub-based split using balance-based selection. Uses the top 3 highest-degree nodes to generate all 3 possible hyperplanes, then selects the one with the best balance (closest to 50/50 split). Returns ------- indices_left, indices_right, hyperplane, offset, balance The balance is returned so the caller can decide whether to accept the split. r rr|r.rr-r/)r0r{r3r5r}rjr7r4r6r r1r2rsrr8)r9rrkrmr:r;rlr~rrrrrrrArgrr<r=r>r?r"r%r@r r!rr$rrBrCrrrangular_hub_splits                             @            r) left_node_numright_node_num)r*r+r(c  Cv|jd| kr| dkrt|||||\} } } }}|tkrC|tjdgtjd|tj |tdtdf||dSt || |||||||| | d t |d}t || |||||||| | d t |d}|| |||t|t|f|tjdgtjddS|tjdgtjd|tj |tdtdf||dS)zRecursive tree builder using hub-based splits. Stops splitting if: - Node size <= leaf_size - max_depth reached - Best split balance < MIN_SPLIT_BALANCE (creates larger leaf instead of bad split) rrrNr ) r0rMIN_SPLIT_BALANCEappendr3arrayr5infr8make_hub_euclidean_treelenr9rrkrmrrr point_indicesr:r max_depth left_indices right_indicesr_offsetrrrrrrrl       rc  Cr)zRecursive tree builder using angular hub-based splits. Stops splitting if: - Node size <= leaf_size - max_depth reached - Best split balance < MIN_SPLIT_BALANCE (creates larger leaf instead of bad split) rrrrNr ) r0rrrr3rr5rr8make_hub_angular_treerrrrrrwrr)r*r+c Cst|}t|jdtj}tjj t }tjj t } tjj t } tjj t } |r>t|||||| | | |||d nt|||||| | | |||d |} | D]} t| | kr`tt| } qQt|| | | | }|S)aBuild an RP tree using simplified hub-based hyperplane selection. This version precomputes global degrees once and uses the top 3 highest-degree nodes at each split to generate all 3 possible hyperplanes. This is simpler and significantly faster than the random sampling approach while maintaining or improving tree quality. Parameters ---------- data : array of shape (n_samples, n_features) The data to build the tree on. neighbor_indices : array of shape (n_samples, n_neighbors) The neighbor graph indices. rng_state : array of int64, shape (3,) The internal state of the rng. leaf_size : int The maximum size of a leaf node. angular : bool Whether to use angular (cosine) or euclidean distance. max_depth : int Maximum tree depth. Returns ------- tree : FlatTree The constructed tree. rr)rpr3aranger0rPr8numbatypedList empty_listdense_hyperplane_type offset_type children_typepoint_indices_typerrrr )r9rkr:rangularrrmrrrrr max_leaf_sizepointsresultrrr make_hub_treesP% rc2 Cs|jd}t||d}|jd} tj|jddtjd} t|D]} | | || <q ttdg} ttdg} td}tj |tj d}t d}t d}t d}tj |tj d}t| D]b}t|d| D]W}||}||}|||||d}|||||d}|||||d}|||||d}td}t ||||\}}t ||||\}} | d } t|||| tj\}} | D]}!||!8}qt d}"t d}#t|D]j} |}$|||| ||| d}%|||| ||| d}&t|||%|&\}'}(|(D]}!|$|!7}$q|$tkr,d|| <|"d7}"q|$t kr;d|| <|#d7}#q| d || <|| dkrM|"d7}"q|#d7}#q|"dks\|#dkr]qmt d})t|D]7} || }*|| }+t|jdD]$},||*|,f}-|-dkrn| |-}.|.dkr||.|+kr|)d7})qwqf|)d })|)|kr|)}|"}|#}|} |} |}t|D] } || || <qqmqc|dks|dkrt d}t d}t|D]} tt|d || <|| dkr|d7}q|d7}qtj |tjd}/tj |tjd}0t d}"t d}#t|D] } || dkr2|| |/|"<|"d7}"q|| |0|#<|#d7}#qt| | f}1|/|0|1|fS) zSimplified hub-based split for sparse euclidean data. Uses the top 3 highest-degree nodes to generate 3 possible hyperplanes, then selects the one that minimizes edge cuts. rr|rrrr.r rKr/)r0r{r3rtr8r6rr5float64r4r7r}rrrrPr2copyr1rrQ)2rRrSspdatarrkrmr:rlr~r idx_to_posrbest_hyperplane_indsbest_hyperplane_datarrbest_edge_cutsrrrArgrr<r=rTrUrVrWr#rXrYrarbr^r r!r$rZr[r\r] edge_cuts point_idx point_sidej_nbro neighbor_posrBrCr_rrrsparse_euclidean_hub_split(s                              U             rc4Cs|jd}t||d}|jd} tj|jddtjd} t|D]} | | || <q ttdg} ttdg} tj|tj d}t d}t d}t d}tj|tj d}t| D]}t|d| D]z}||}||}|||||d}|||||d}|||||d}|||||d}t |}t |}t |t krd}t |t krd}||tj}||tj}t||||\}} t | }!t |!t krd}!t| jdD] }"| |"|!| |"<qt d}#t d}$t|D]q} td }%|||| ||| d}&|||| ||| d}'t|| |&|'\}(})|)D]}*|%|*7}%q2|%t krId|| <|#d7}#q|%t krYd|| <|$d7}$q| d || <|| dkrl|#d7}#q|$d7}$q|#dks||$dkr}qht d}+t|D]7} || },|| }-t|jdD]$}.||,|.f}/|/dkrn| |/}0|0dkr||0|-kr|+d7}+qq|+d }+|+|kr|+}|#}|$}|} | } t|D] } || || <qqhq^|dks|dkrt d}t d}t|D]} t t|d || <|| dkr|d7}q|d7}qtj|tjd}1tj|tjd}2t d}#t d}$t|D] } || dkrP|| |1|#<|#d7}#q;|| |2|$<|$d7}$q;t| | f}3|1|2|3td fS) zSimplified hub-based split for sparse angular data. Uses the top 3 highest-degree nodes to generate 3 possible hyperplanes, then selects the one that minimizes edge cuts. rr|rrrrr r-r.r/)r0r{r3rtr8r6rr5r4r7r}r r1r2rPrrrrrrQ)4rRrSrrrkrmr:rlr~rrrrrrrrrrArgrr<r=rTrUrVrWr>r?rMrNrXrYr@r%r r!r$rZr[r\r]r^rrrrrorrBrCr_rrrsparse_angular_hub_splits                              X            rc C0|jd| krn| dkrnt||||||| \} }}}t|||| |||||| | | | d t| d}t|||||||||| | | | d t| d}|||||t|t|f| tjdgtjddS|tjdgdggtjd|tj |tdtdf| |dS)zDRecursive tree builder using simplified sparse euclidean hub splits.rr rrrN) r0rmake_sparse_hub_euclidean_treerrr3r8rrrrRrSrrrkrmrrrrr:rrrrr_rrrrrrrRf     rc Cr)zBRecursive tree builder using simplified sparse angular hub splits.rr rrrN) r0rmake_sparse_hub_angular_treerrr3r8rrrrrrrrrrcCst|}t|jddtj} tjj t } tjj t } tjj t } tjj t } |rBt|||| ||| | | | |||d nt|||| ||| | | | |||d |}| D]}t||krftt|}qWt| | | | |}|S)aBuild a sparse RP tree using simplified hub-based hyperplane selection. This version precomputes global degrees once and uses the top 3 highest-degree nodes at each split to generate all 3 possible hyperplanes. Parameters ---------- inds : array CSR format index array of the matrix. indptr : array CSR format index pointer array of the matrix. spdata : array CSR format data array of the matrix. neighbor_indices : array of shape (n_samples, n_neighbors) The neighbor graph indices. rng_state : array of int64, shape (3,) The internal state of the rng. leaf_size : int The maximum size of a leaf node. angular : bool Whether to use angular (cosine) or euclidean distance. max_depth : int Maximum tree depth. Returns ------- tree : FlatTree The constructed tree. rr r)rpr3rr0rPr8rrrrsparse_hyperplane_typerrrrrrr )rRrSrrkr:rrrrmrrrrrrrrrrrmake_sparse_hub_treesX) rr|c Cs|jd}t||}tj|tdtjd}tj|tjd}t|D]U}|||} | ||dkrw|d} | dkrR| || dkrR| d8} | dkrR| || dksBt|d| dD]} || d|| <|| d|| <qZ| || <|||| <q"|S)zGet the indices of the top k highest-degree points for bit data. Also returns the pair with maximum Hamming distance among the top k. rrrr rr) rr9rmrurlrvrwrxrryrzrnrrrget_top_k_hub_indices_bitRs$    rc% Cs0|jd}|jd}t|||d}|jd}tj|jddtjd} t|D]} | | || <q&tj|dtjd} tj|tj d} t d} t d}t d}tj|tj d}t|D]:}t|d|D]/}||}||}tj|dtjd}|d|}||d}t|D]"}|||f|||fA}||||f@||<||||f@||<qt d}t d}t|D]`} t d }t|D]"}|t ||||| |f@7}|t ||||| |f@8}q|t krd|| <|d7}q|t krd|| <|d7}q| d|| <|| dkr|d7}q|d7}q|dks'|dkr(qft d}t|D]7} || }|| }t|jdD]$} ||| f}!|!dkrQn| |!}"|"dkre||"|kre|d7}qBq1|d}|| kr|} |}|}t|dD] }||| |<q~t|D] } || | | <qqfq\|dks|dkrt d}t d}t|D]} tt|d| | <| | dkr|d7}q|d7}qtj|tjd}#tj|tjd}$t d}t d}t|D] } | | dkr|| |#|<|d7}q|| |$|<|d7}q|#|$| t d fS) zSimplified hub-based split for bit-packed data. Uses the top 3 highest-degree nodes to generate 3 possible hyperplanes, then selects the one that minimizes edge cuts. r rr|rrr/rNr.)r0rr3rtr8r6rjrEr4r7r}r5rFr2r1r)%r9rrkrmr:r;rlr~rrrrrrrrrArgrr<r=r"rGrHr%rIr r!r$rrrrrorrBrCrrr bit_hub_splitus                           F            rc  Cs$|jd| krh| dkrht|||||\} } } }t|| |||||||| | d t|d}t|| |||||||| | d t|d}|| |||t|t|f|tjdgtjddS|tjtdgtjd|tj |tdtdf||dS)z7Recursive tree builder using simplified bit hub splits.rr rrN) r0rmake_bit_hub_tree_recursiverrr3r8rrEr)r9rrkrmrrrrr:rrrrr_rrrrrrrsZ     rc Cst|}t|jdtj}tjj t }tjj t }tjj t } tjj t } t||||||| | |||d |} | D]} t| | krNtt| } q?t||| | | } | S)aBuild a bit-packed RP tree using simplified hub-based hyperplane selection. This version precomputes global degrees once and uses the top 3 highest-degree nodes at each split to generate all 3 possible hyperplanes. Parameters ---------- data : array of shape (n_samples, n_features) The bit-packed data to build the tree on. neighbor_indices : array of shape (n_samples, n_neighbors) The neighbor graph indices. rng_state : array of int64, shape (3,) The internal state of the rng. leaf_size : int The maximum size of a leaf node. max_depth : int Maximum tree depth. Returns ------- tree : FlatTree The constructed tree. rr)rpr3rr0rPr8rrrrbit_hyperplane_typerrrrrr )r9rkr:rrrmrrrrrrrrrrrmake_bit_hub_tree>s4  r)r*r(c  C|jd|krb|dkrbt|||\} } } } t|| |||||||d t|d} t|| |||||||d t|d}|| || |t| t|f|tjdgtjddS|tjdgtjd|tj |tdtdf||dSNrr rrr) r0rLmake_euclidean_treerrr3r8rr5rr9rrrrrr:rrrrr_rrrrrrr}sR     r)rrrc  Crr) r0rDmake_angular_treerrr3r8rr5rrrrrrR     rc  Cr)Nrr rr) r0rJ make_bit_treerrr3r8rrErrrrrr rrc  C$|jd| krh| dkrht|||||\} } } }t|||| |||||| | d t|d}t|||| |||||| | d t|d}|| |||t|t|f|tjdgtjddS|tjdgdggtjd|tj |tdtdf||dSr) r0rcmake_sparse_euclidean_treerrr3r8rrrrRrSr9rrrrrr:rrrrr_rrrrrrrE s^      rc  Crr) r0r`make_sparse_angular_treerrr3r8rrrrrrrr sZ     r)r*c Cst|jdtj}tjjt }tjjt }tjjt }tjjt } |r8t |||||| |||d n t|||||| |||d |} | D]} t| | krXtt| } qIt|||| | } | S)Nrr)r3rr0rPr8rrrrrrrrrrrr r9r:rrrrrrrrrrrrrrmake_dense_tree sF   rc Cst|jddtj}tjjt }tjjt } tjjt } tjjt } |r' s  zmake_forest..c3,|]}tt|dVqdSr)rrrrrrrr4  c3rr)rrrrrrrr; rzRandom Projection forest initialisation failed due to recursionlimit being reached. Something is a little strange with your graph_data, and this may take longer than normal to compute.)maxrsr3r8randint INT32_MIN INT32_MAXrPint64scipysparseisspmatrix_csrrParallelr6 RuntimeErrorRecursionError SystemErrorrtuple) r9 n_neighborsn_treesrr: random_staterrbit_treerrrrr make_forest s>      !r cCsd}tt|jD]}|j|ddkr!|j|ddkr!|d7}q tj||fdtjd}d}tt|jD]+}|j|ddksJ|j|ddkra|j|jd}|j|||d|f<|d7}q6|S)Nrrr r)r6rrr3rtr8rr0)treern_leavesrr leaf_indexrrrrget_leaves_from_treeK s$$rcs8tdd|Dtjdddfdd|D}|S)NcSsg|]}|jqSr)rrrp_treerrrr^ sz.rptree_leaf_array_parallel..rrrc3s |] }tt|VqdSN)rrrrrrrr_ s  z-rptree_leaf_array_parallel..)r3rrr) rp_forestrrrrrptree_leaf_array_parallel] s rcCs(t|dkr tt|StdggS)Nrr)rr3rQrr)rrrrrptree_leaf_arrayf s rc Cs|j|ddkr-|t|j|}| ||df<| ||df<|j||||<||fS|j|||<|j|||<|d||df<|} t||||||d||j|d\}}|d|| df<t||||||d||j|d\}}||fSr)rrrrrrecursive_convert r rrrrnode_num leaf_start tree_nodeleaf_end old_node_numrrrrn s@    rc Cs |j|ddkr-|t|j|}| ||df<| ||df<|j||||<||fS|j|||ddd|j|jdf<|j|||<|d||df<|} t||||||d||j|d\}}|d|| df<t||||||d||j|d\}}||fSr)rrrrr0rrecursive_convert_sparserrrrr sB     r)r+cCsPd}d}tt|jD]}|j|ddkr|d7}|d7}q |d7}q ||fSr)r6rr)r n_nodesr rrrrnum_nodes_and_leaves s  r c Cs0t|\}}d}|jdjdkr.|jdjtjkr|d}n|}tj||f|jdjd}nd}|}tj|d|ftjd}d|dddddf<tj|tjd}tdtj |dftjd} tdtj |tjd} |rt |||| | ddt |j dnt |||| | ddt |j dt||| | |jS)NFrr r/rTr)r rndimrr3rErjr5r8onesrrrrr r) r  data_sizedata_dimrr  is_sparsehyperplane_dimrrrrrrrconvert_tree_format s0  r'cCs|j|j|j|j|jf}|Srr r rrrrdenumbaify_tree sr*cCs(t|t|t|t|t|t}|Sr)r FLAT_TREE_HYPERPLANESFLAT_TREE_OFFSETSFLAT_TREE_CHILDRENFLAT_TREE_INDICESFLAT_TREE_LEAF_SIZEr)rrrrenumbaify_tree sr0) intersectionrr)parallelr(r+cCsrd}t|jdD]$}t|||j|j|j|j|}t|||}|t |jddk7}q |t |jdS)Nr.rr ) rpranger0rrrrrrr5)r rkr9r:rr leaf_indicesr1rrr score_tree s r5)rr)r*r(r+cCs|jd}|jd}d}t|j}t|D]b}t|}|j|d}|j|d} |dkrw| dkrw|j|} | jd} t| D]6} | | } || }d}t|D]}||}t| D]}| ||krh|d7}nqZqP|t|t|7}q@q|t|S)a~Score a tree by measuring how well leaves contain nearest neighbors. For each point, computes the fraction of its k nearest neighbors that are in the same leaf. Returns the average of this fraction across all points. A score of 1.0 means all neighbors are always in the same leaf (perfect). A score of 0.0 means no neighbors are ever in the same leaf (worst). rr r.r)r0rrr6rr8rr5)r rkrlru total_scorerrr left_child right_childr4rrnidx neighborsrnirolirrrscore_linked_tree% s4           r=)rq)rr)rFr)r|)NFFr)iwarningsrnumpyr3r scipy.sparserpynndescent.sparserrrrrpynndescent.utilsrr r collectionsr r2iinfor8rsrrrr r5rrrrErrtypeofrrrr6rFnjittypesTuplerr}rDrJrLr`rcFAST_SPLIT_THRESHOLDrirpr{rrrrrrrrrrrrrrrrListTyperrrrrrrbooleanArrayintpuint16rrrrrrr rrrrrr r'r+r,r-r.r/r*r0r5r=rrrrs  "2  r"2  o"2  d  |   3 | w T T W   K K _  | C >  <  <  < D B  ) 5              L  &  (  "