ukiBdZddlmZddlZddlmZddlmZddlmZddlm Z ddl m Z dd l m Z dd l mZdd l mZdd lmZdd lmZddlmZddlmZddlmZ d&dededededededeeeffdZ d&dededededededeeeffdZdZdZ dZ!ddd Z"d!Z#d"Z$ejJd#Z&de&_'e&jQeejRe&e&jUeejVe&ee"dejVe&e"d$%e#ejXe&<e$e jZe&<y)'aANN (Approximate Nearest Neighbor) computes top-k with a configurable recall rate. This package only optimizes the TPU backend. For other device types it fallbacks to sort and slice. Usage:: import functools import jax # MIPS := maximal inner product search # Inputs: # qy: f32[qy_size, feature_dim] # db: f32[db_size, feature_dim] # # Returns: # (f32[qy_size, k], i32[qy_size, k]) @functools.partial(jax.jit, static_argnames=["k", "recall_target"]) def mips(qy, db, k=10, recall_target=0.95): dists = jax.lax.dot(qy, db.transpose()) # Computes max_k along the last dimension # returns (f32[qy_size, k], i32[qy_size, k]) return jax.lax.approx_max_k(dists, k=k, recall_target=recall_target) # Multi-core example # Inputs: # qy: f32[num_devices, qy_size, feature_dim] # db: f32[num_devices, per_device_db_size, feature_dim] # db_offset: i32[num_devices] # db_size = num_devices * per_device_db_size # # Returns: # (f32[qy_size, num_devices, k], i32[qy_size, num_devices, k]) @functools.partial( jax.pmap, # static args: db_size, k, recall_target static_broadcasted_argnums=[3, 4, 5], out_axes=(1, 1)) def pmap_mips(qy, db, db_offset, db_size, k, recall_target): dists = jax.lax.dot(qy, db.transpose()) dists, neighbors = jax.lax.approx_max_k( dists, k=k, recall_target=recall_target, reduction_input_size_override=db_size) return (dists, neighbors + db_offset) # i32[qy_size, num_devices, k] pmap_neighbors = pmap_mips(qy, db, db_offset, db_size, 10, 0.95)[1] # i32[qy_size, num_devices * k] neighbors = jax.lax.collapse(pmap_neighbors, start_dimension=1, stop_dimension=3) Todos:: * On host top-k aggregation * Inaccurate but fast differentiation )partialN)ad_util)core)dispatch)dtypes)take_along_axis)ad)batching)mlir)_jax)ir)func)hlo)ArrayToperandkreduction_dimension recall_targetreduction_input_size_overrideaggregate_to_topkreturnc :tj||||d||S)aReturns max ``k`` values and their indices of the ``operand`` in an approximate manner. See https://arxiv.org/abs/2206.14286 for the algorithm details. Args: operand : Array to search for max-k. Must be a floating number type. k : Specifies the number of max-k. reduction_dimension : Integer dimension along which to search. Default: -1. recall_target : Recall target for the approximation. reduction_input_size_override : When set to a positive value, it overrides the size determined by ``operand[reduction_dim]`` for evaluating the recall. This option is useful when the given ``operand`` is only a subset of the overall computation in SPMD or distributed pipelines, where the true input size cannot be deferred by the operand shape. aggregate_to_topk : When true, aggregates approximate results to the top-k in sorted order. When false, returns the approximate results unsorted. In this case, the number of the approximate results is implementation defined and is greater or equal to the specified ``k``. Returns: Tuple of two arrays. The arrays are the max ``k`` values and the corresponding indices along the ``reduction_dimension`` of the input ``operand``. The arrays' dimensions are the same as the input ``operand`` except for the ``reduction_dimension``: when ``aggregate_to_topk`` is true, the reduction dimension is ``k``; otherwise, it is greater equals to ``k`` where the size is implementation-defined. We encourage users to wrap ``approx_max_k`` with jit. See the following example for maximal inner production search (MIPS): >>> import functools >>> import jax >>> import numpy as np >>> @functools.partial(jax.jit, static_argnames=["k", "recall_target"]) ... def mips(qy, db, k=10, recall_target=0.95): ... dists = jax.lax.dot(qy, db.transpose()) ... # returns (f32[qy_size, k], i32[qy_size, k]) ... return jax.lax.approx_max_k(dists, k=k, recall_target=recall_target) >>> >>> qy = jax.numpy.array(np.random.rand(50, 64)) >>> db = jax.numpy.array(np.random.rand(1024, 64)) >>> dot_products, neighbors = mips(qy, db, k=10) Trrris_max_krrapprox_top_k_pbindrrrrrrs K/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/lax/ann.py approx_max_kr \s2b     -!$A)  ++c :tj||||d||S)a Returns min ``k`` values and their indices of the ``operand`` in an approximate manner. See https://arxiv.org/abs/2206.14286 for the algorithm details. Args: operand : Array to search for min-k. Must be a floating number type. k : Specifies the number of min-k. reduction_dimension: Integer dimension along which to search. Default: -1. recall_target: Recall target for the approximation. reduction_input_size_override : When set to a positive value, it overrides the size determined by ``operand[reduction_dim]`` for evaluating the recall. This option is useful when the given operand is only a subset of the overall computation in SPMD or distributed pipelines, where the true input size cannot be deferred by the ``operand`` shape. aggregate_to_topk : When true, aggregates approximate results to the top-k in sorted order. When false, returns the approximate results unsorted. In this case, the number of the approximate results is implementation defined and is greater or equal to the specified ``k``. Returns: Tuple of two arrays. The arrays are the least ``k`` values and the corresponding indices along the ``reduction_dimension`` of the input ``operand``. The arrays' dimensions are the same as the input ``operand`` except for the ``reduction_dimension``: when ``aggregate_to_topk`` is true, the reduction dimension is ``k``; otherwise, it is greater equals to ``k`` where the size is implementation-defined. We encourage users to wrap ``approx_min_k`` with jit. See the following example for nearest neighbor search over the squared l2 distance: >>> import functools >>> import jax >>> import numpy as np >>> @functools.partial(jax.jit, static_argnames=["k", "recall_target"]) ... def l2_ann(qy, db, half_db_norms, k=10, recall_target=0.95): ... dists = half_db_norms - jax.lax.dot(qy, db.transpose()) ... return jax.lax.approx_min_k(dists, k=k, recall_target=recall_target) >>> >>> qy = jax.numpy.array(np.random.rand(50, 64)) >>> db = jax.numpy.array(np.random.rand(1024, 64)) >>> half_db_norm_sq = jax.numpy.linalg.norm(db, axis=1)**2 / 2 >>> dists, neighbors = l2_ann(qy, db, half_db_norm_sq, k=10) In the example above, we compute ``db^2/2 - dot(qy, db^T)`` instead of ``qy^2 - 2 dot(qy, db^T) + db^2`` for performance reason. The former uses less arithmetic and produces the same set of neighbors. Frrrs r approx_min_kr#s2j     -!$A)  ++r!c|dkrtd|t|jdk(r$tdj |jt |j}|||krtdj |||t j|jtjs td||}|r|||<nStj||fr*tj|t|||||d||<ntd|d|d|j } | j"|*tj$d |d |j'd |j)||j|j*|j,| |j)|tjtj.|j,| fS)Nrzk must be positive, got z5approx_top_k operand must have >= 1 dimension, got {}z;k must be smaller than the size of reduction_dim {}, got {}zoperand must be a floating typezSapprox_top_k with aggregate_to_topk=False not yet implemented when either the `k` (z$) or the reduction dimension size (z) are symboliczreduction dimension z in operand z@ should be unsharded i.e. the spec of that dim should be `None`.)shapedtype weak_typevmasharding)r%r&r(r)) ValueErrorlenr% TypeErrorformatlistr issubdtyper&npfloatingris_constant_shaper "approx_top_k_reduction_output_sizeNotImplementedErrorr)specShardingTypeError str_shortupdater'r(int32) rrrrrrrdimsreduction_input_size operand_ss r_approx_top_k_abstract_evalr=s!V /s3 441 KRR   gmm $ " ELL $ %q * ++   7=="++ 6 6 7712 !D  3Q78 $ G Gc$iM;L%!''(!*D   3'';&|c}||||g| j@jBg|| }|jFSt jD||f\}t j<d |j4Dcgc]}t j>|c}|||||g| j@jBg|| }|jFScc}wcc}wcc}w)Nc3PK|]}t|tj ywN) isinstancer ShapedArray).0xs r z)_approx_top_k_lowering..s CZ4++ , Cs$&rz"operand must be an array, but was ) dimension) reduction_dimrrr is_fallbackc3ZK|]#}tj|j%ywrn)rr2r%)rqaval_outs rrsz)_approx_top_k_lowering..9sNH   /Ns)+top_k ApproxTopK)raoperandscalled_computationsbackend_config result_shapeszstablehlo.dynamic_approx_top_k)$avals_inallr%r+r*r dtype_to_ir_typer&r F32TyperLrjiotarrpr0r9rconstantDenseElementsAttrrB ir_constantreshapei64_attr FloatAttrBoolAttr avals_out shape_tensoreval_dynamic_shapeis_constant_dim custom_callaval_to_ir_typenamevalueeval_dynamic_shape_as_valsresults)r]rrrrrrrrkop_shapeop_dimsrA recall_typercrinit_arginit_val_arrayinit_valrrrzavaloutk_values r_approx_top_k_loweringrs  Ccll C CC C \\!_ " "(]a 9(D EE '  ! !#,,q/"7"7 8'  +1g,)<<'Wh?* 3((a)>)>I0 2$\\"..22288B<@ A((a)>)>I.   n44R8 9(mm$78gg''++KG''**../@A mm12 4. $(GG$4$4$8$8$BN=!N NNM '  $11#x~~FG'M' !"mmA.N7   =@]]KTd**40K484'__223%#  %C" ..sQD9HG   (=@]]KTd**40K48W='__223%#  %C /'LLs:O O O% c t|dk(sJt|dk(sJ|\}|\} t|jD cgc] } | | us|  } } | |}tj |||||||| | ffScc} w)NrEr)r+rangendimrr) batch_operands batch_axesrrrrrrr batch_axisddim_maps r_approx_top_k_batch_rulerUs ^  !! ! ZA   ('+*gll+ C1q /BQ C' C 34     -!$A)  +.8,D EE Ds A5 A5c|\}|\} |rt||||||\} } nt||||||\} } t| tjur tjj | } n/| j } t| }|dkr||z }t| | |} | | f| tjj | ffS)Nr)axis) r r#typerZerofrom_primal_valuer%r+r)primalstangentsrrrrrrrtangentval_outarg_out tangent_out arg_shaperanks r_approx_top_k_jvprps(' (' #GQ0C$1$A$57GW $GQ0C$1$A$57GW ']gll",,009K I y>DQT!!'79LMK 7 k7<<+I+I'+RS SSr! approx_top_ktpu)platform)rugffffff?ruT).__doc__ functoolsrnumpyr0jax._srcrrrrjax._src.numpy.indexingrjax._src.interpretersr r r jax._src.libr jax._src.lib.mlirr jax._src.lib.mlir.dialectsrrjax._src.typingrintfloatbooltupler r#r=rBrjrrr Primitivermultiple_resultsdef_implapply_primitivedef_abstract_evalregister_loweringprimitive_batchersprimitive_jvpsrvr!rrs7r3$*& +*! -/(,68+/ 8+%8+8+&)8+!&8+14 8+ %) 8+ 5:%,4G 8+z-/(,68+/ <+%<+<+&)<+!&<+14 <+ %) <+ 5:%,4G <+~&.PB2?D<|E6T4 /"& 8 8.IJ !<=~4tDF~'=!&(.FN+$5.!r!