
    rh\0                         d dl Z d dlZd dlZd dlZ ej
                  e      Ze j                  ddfdZ	e j                  Z
ddZe j                  ddfdZddZddZdd	Z	 	 dd
ZddZy)    NFc                    t         j                  d| j                  |fz         t        j                         }| j                  \  }}t	        j
                  |      }	t	        j                  |||	      }
t	        j                  ||      }|dk(  rt	        j                         }|rKt         j                  d|z         t	        j                         }||_
        t	        j                  |||      }d}|D ]  }|j                  d   }|j                  |       |j                  | |      \  }}||z  }|
j                  ||       |j                          ||z  }t         j                  d|t        j                         |z
  fz          |
j!                          t         j                  dt        j                         |z
  |fz         |
j"                  |
j$                  fS )	zComputes the exact KNN search results for a dataset that possibly
    does not fit in RAM but for which we have an iterator that
    returns it block by block.
    z%knn_ground_truth queries size %s k=%dkeep_maxr   running on %d GPUscongpur   %d db elements, %.3f szGT time: %.3f s (%d vectors))LOGinfoshapetimefaissis_similarity_metric
ResultHeap	IndexFlatget_num_gpusGpuMultipleClonerOptionsshardindex_cpu_to_all_gpusaddsearch
add_resultresetfinalizeDI)xqdb_iteratorkmetric_typer   r
   t0nqdr   rhindexr	   i0xbinir   r   s                     r/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/faiss/contrib/exhaustive_search.pyknn_ground_truthr,      s   
 HH4!}DE	BHHEB))+6H			"a(	3BOOA{+Erz!!#%,-++-++EbtD 
B DYYq\		#||B"1	R
a
b)Rr1A,BBCD KKMHH+tyy{R/?.DDE44:    c                 P   | j                   \  }}t        |t        j                        }t        j                  |j
                        }|rt        |      n
t        |      }t        |j                  |      }	t        j                  d| d|	 d| d|        t        j                         }
|j                  | |	      \  }}t        j                         |
z
  }|r|dz  dk  sJ |j                  d      }d}d	}||s|d	d	|	d
z
  f   |k  }n|d	d	|	d
z
  f   |kD  }|j                         dkD  rt        j                  d|j                         z         t        j                         }
t        |t         j"                        rN|}|rt        j$                  |dz        }n t        j&                  ||j
                        }|j)                  |       |j+                  | |   |      \  }}}|r|j                  d      }t        j                         |
z
  }t        j                  d       t        j                         }
|rt        j,                  nt        j.                  } |||	||      }	 t        j0                  } ||      |_         ||      |_        |C |      |_         |      |_         ||j;                  d            |_         |      |_        t!        j@                  |d
z   d      }|jC                   ||             |d   }t!        j@                  ||jD                        }t!        j@                  |d      }|jG                   ||       ||             t        j                         |
z
  }!t        j                  d|dd|dd|!dd       |||fS )aA  GPU does not support range search, so we emulate it with
    knn search + fallback to CPU index.

    The index_cpu can either be:
    - a CPU index that supports range search
    - a numpy table, that will be used to construct a Flat index if needed.
    - None. In that case, at most gpu_k results will be returned
    zGPU search z queries with k=z is_binary_index=z
 keep_max=   i   int16r   N   zCPU search remain %dcombineint64dtyper   ztimes z.3fzs s)*r   
isinstancer   IndexBinaryr   r"   intfloatminntotalr   debugr   r   astypesumnpndarrayIndexBinaryFlatr   r   range_searchCombinerRangeKNNint16CombinerRangeKNNfloatswig_ptrr   r   maskD_remainview
lim_remainI_remainemptycompute_sizesr5   write_resultrange	METRIC_L2appendcumsumlenhstack)"r   r2	index_gpu	index_cpugpu_kr$   r%   is_binary_indexr   r!   r#   r   r   t1t2rJ   rG   xbrH   rK   CombinerRangeKNNcombinerspL_resnresD_resI_resnrinvl0l1dit3s"                                     r+   range_search_gpurk   :   s/    HHEB E,=,=>O)))*?*?@H#RrBIe$AII
bT*!u,>oa-@(1NP	BB"DAq	r	B1uu}}HHW	
BJQAX;#DQAX;#D88:>II,txxz9:B)RZZ0" % 5 5a!e <I %93H3H IIb!-6-C-CBtHb-Q*J(#??73r!BIIi	B (7#### 
  Ar84H^^U
U
!tHHM "8H"$Z__W%=">H "8Haw/r%y)RyQWW-W-biE3( 
r	BIIr#hbC2c(!45%r-   c                 2   | j                   \  }}t        j                         }t        j                  | d      } t	        j
                  ||      }	|dk(  rt	        j                         }|rKt        j                  d|z         t	        j                         }
||
_
        t	        j                  |	|
|      }d}t        |      D cg c]  }g  }}t        |      D cg c]  }g  }}|D ]  }|j                   d   }|dkD  r4j                  |       t        | |||      \  }}}|j                          n7|	j                  |       |	j!                  | |      \  }}}|	j                          ||z  }t        |      D ]C  }||   ||dz      }}||kD  s||   j#                  |||        ||   j#                  |||        E ||z  }t        j                  d|t        j                         |z
  fz          t        j$                  dd	      }t        j$                  dd      }|D cg c]  }|g k7  rt        j&                  |      n|  }}|D cg c]  }|g k7  rt        j&                  |      n|  }}|D cg c]  }t)        |       }}t)        |      |k(  sJ t        j$                  |dz   d
      }t        j*                  |      |dd |t        j&                  |      t        j&                  |      fS c c}w c c}w c c}w c c}w c c}w )zComputes the range-search search results for a dataset that possibly
    does not fit in RAM but for which we have an iterator that
    returns it block by block.
    float32r4   r   r   r   r   r1   r   r3   uint64N)r   r   r@   ascontiguousarrayr   r   r   r   r   r   r   r   rO   r   rk   r   rC   rQ   zerosrT   rS   rR   )r   r    	thresholdr"   r   r
   r$   r%   r#   r'   r	   rV   r(   _ir   r   r)   r*   lims_iDiIijrg   rh   empty_Iempty_Dre   sizeslimss                                r+   range_ground_truthr{      s    HHEB	B			b		2BOOA{+Erz!!#%,-++-//"4H	 
BBi  A Bi  A  DYYq\!8MM#-b)YLNFBOOIIcN"//I>NFBKKM
br 	'AAYq1uBBw!Br"I&!Br"I&		'
 	b)Rr1A,BBC#D& hhq(Ghhq	*G9:;A!r'"))A,w
.;A;9:;A!r'"))A,w
.;A;SVEu:88BF(+DyyDH1ryy|++= 	! . 	<;s   	L 	L-#L
#L?Lc                     |r||kD  }n||k  }t        j                  |       }d}t        |       D ].  \  }}	t        |	      }	||||	z    j	                         ||<   ||	z  }0 |||   ||   fS )z select a set of results r   )r@   
zeros_like	enumerater9   r?   )
ra   disidsthreshr   rG   new_nresore   rd   s
             r+   threshold_radius_nresr      s    V|V|}}T"H	A4 2W1QVn((*	R SYD	))r-   c                     |r||kD  }n||k  }t        j                  |       }t        |       dz
  }t        |      D ].  }| |   | |dz      }
}	||   ||	|
 j	                         z   ||dz   <   0 |||   ||   fS )z= restrict range-search results to those below a given radius r1   )r@   r}   rS   rO   r?   )rz   r   r   r   r   rG   new_limsnre   rg   rh   s              r+   threshold_radiusr      s    V|V|}}T"HD	AA1X :a$q1u+B"1+R(99Q: SYD	))r-   c           	      <   t        j                  | D cg c]  \  }}}|
 c}}      }t        |      |kD  sJ |r)|j                  t        |      |z
  dz
         |d|z
     }n|j                  |       ||   }|j                  dk(  rt        |      }nt        |      }t        j                  d|z         d}t        |       D ]3  \  }\  }	}}
t        |	||
||      \  }	}}
|t        |      z  }|	||
f| |<   5 t        j                  d|z         ||fS c c}}w )zfind radius that reduces number of results to target_nres, and
    applies it in-place to the result batches used in
    range_search_max_resultsr1   r   rm   z   setting radius to %sr   r   z.   updated previous results, new nb results %d)r@   rT   rS   	partitionr5   r:   r9   r   r=   r~   r   )res_batchestarget_nresr   _r   alldisradiustotresre   ra   r   s              r+   apply_maxresr      s+    YY[9	39:Fv;$$$V{2Q67[()%$||y vVII'&01F(5 (D#s.#sFX7c3#c(sCA	(
 II>GH6>+ :s   D
c           
         t        | t        j                        }||J t        d|z        }||J t        |dz        }|dk(  rt        j                         }|rLt
        j                  d|z         t        j                         }	||	_        t        j                  | |	|      }
nd}
t        j                         }dx}}dx}x}}g }|D ]u  }t        j                         }t
        j                  dt        |       d	       |
rt        |||
|       \  }}}n| j                  ||      \  }}}|d
d |dd z
  }|t        |      z  }|t        |      z  }t        j                         }|r|j                  d      }|t        |      z  }|j!                  |||f       |K||kD  rFt
        j                  d||fz         t#        ||| j$                  t        j&                  k(        \  }}t        j                         }|||z
  z  }|||z
  z  }t
        j                  dt        j                         |z
  ||fz         x t
        j                  d||||fz         |r1||kD  r,t#        ||| j$                  t        j&                  k(        \  }}t)        j*                  |D cg c]  \  }}}|
 c}}}      }t)        j*                  |D cg c]  \  }}}|
 c}}}      }t)        j*                  |D cg c]  \  }}}|
 c}}}      }t)        j,                  t        |      d
z   d      }t)        j.                  |      |d
d ||||fS c c}}}w c c}}}w c c}}}w )a  Performs a range search with many queries (given by an iterator)
    and adjusts the threshold on-the-fly so that the total results
    table does not grow larger than max_results.

    If ngpu != 0, the function moves the index to this many GPUs to
    speed up search.
    Ng?g      ?r   r   r   r   z
searching z vectorsr1   r0   z-too many results %d > %d, scaling back radiusr   z'   [%.3f s] %d queries done, %d resultszBsearch done in %.3f s + %.3f s, total %d results, end threshold %grn   r4   )r7   r   r8   r9   r   r   r   r   r   r   r   r=   rS   rk   rC   r>   rQ   r   r"   METRIC_INNER_PRODUCTr@   rT   rp   rR   ) r'   query_iteratorr   max_resultsmin_resultsr   r
   clip_to_minrY   r	   rV   t_startt_searcht_post_processqtotr   
raw_totresr   xqir#   rs   rt   ru   nres_irZ   r[   dis_iids_ira   r   r   rz   s                                    r+   range_search_max_resultsr     s\    !(9(9:O&&&#+,&&&++,rz!!#%,-++-//"4H		iikG !!H~!""D"6JK 2YY[		Js3xj12-c69eLNFB"//V<NFBfSbk)c"g
CYY[7#B#b'FB+,"v';HHDk*+ ,)[**e.H.HHNFF YY[BG"r'!		;IIK'!4?1 1 	2=2B HHLnffP6 	6
 v+%&&%*D*DD

 99EE!5fEFD
)){CC3vueUC
DC
)){CC3vueUC
DC88CIM2DyyDH4c!! FCCs   +MMM&c              #      K   t        |       }|}d}||k  r+| |||z    }| ||k  r|dz  }|t        |      z  }||k  r*yyw)z produces batches of progressively increasing sizes. This is useful to
    adjust the search radius progressively without overflowing with
    intermediate results r      N)rS   )r   start_bsmax_bsr$   bsre   r   s          r+   exponential_query_iteratorr   c  s\      
RB	B	A
b&1r6l	;!GB	SX b&s   >AA)i   )F)NNFr   F)    i N  )r   r   numpyr@   logging	getLogger__name__r   rP   r,   knnrk   r{   r   r   r   r   r    r-   r+   <module>r      s       g!5:__EXZ $N ii
[| @E"3,l**: <@>CY"xr-   