ukiF:ddlmZddlmZddlmZddlmZddlZddl Z ddl m Z ddl m Z ddl mZdd l m Zdd l mZdd l mZdd lmZdd lmZddlmZddlmZddlmZmZddlmZddlmZddlm Z m!Z!m"Z" d ddZ# ddZ$dZ% d d dZ& d! d"dZ' d! d"dZ( d! d"dZ) d! d"dZ*y)#) annotations)Callable)partial)AnyN)config)core)dtypes)numpy) tree_util)util)lax)slicing)indexing) reductions)check_arraylikepromote_dtypes) auto_axes) NamedSharding)Array ArrayLikeIndexc tj|}t|trt j |j tjr~t j|j j|cxkr,t j|j jkr%nn"tj||j }ntj|}tjj||jj} t!j"| \} } t%t&|| ||||} |*t)| ||j*j,||| S| ||t/| S)aHelper for indexed updates. Computes the value of x that would result from computing:: x[idx] op= y except in a pure functional way, with no in-place updating. Args: x: ndarray to be updated. idx: None, an integer, a slice, an ellipsis, an ndarray with integer dtype, or a tuple of those indicating the locations of `x` into which to scatter- update the values in `y`. y: values to be scattered. scatter_op: callable, one of lax.scatter, lax.scatter_add, lax.scatter_min, or lax_scatter_max. indices_are_sorted: whether `idx` is known to be sorted unique_indices: whether `idx` is known to be free of duplicates Returns: An ndarray representing an updated `x` after performing the scatter-update. dtype) scatter_optreedefindices_are_sortedunique_indicesmodenormalize_indices) out_shardingaxes)jnpasarray isinstanceintnp issubdtyperintegeriinfominmaxr NDIndexerfrom_raw_indicesshapeexpand_bool_indicesr tree_flattenr _scatter_implrmesh explicit_axestuple) xidxyrrrrr r!indexer dynamic_idxrinternal_scatters O/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/ops/scatter.py_scatter_updater=*s,2 kk!n!CR]]177BJJ?hhqwwq9BHHQWW$5$9$99 AQWW%A AA    / /QWW = Q Q S'"//8+w G+#$) +  9%L&++99 ![ ** !Qk 2 33c ztj|} tj|} tj||sbt j dtj|dtj|dtjjdttj||} | jtj|j |} tj"| j$r|St'||\}}t)j*|t-| j$| j.}t)j0|| j2}| j4r tj6|| j4}| j8r tj:|| j8}t=j>| j@jB| j@jD| j@jF| j@jH| j@jJ} ||| jL|| | jNxs|| jPxs|| }| j8r tj0|| j8}tjR|| | S) NzLscatter inputs have incompatible types: cannot safely cast value from dtype=z to dtype=z with jax_numpy_dtype_promotion=z6. In future JAX releases this will result in an error.)r )r!axis)update_window_dimsinserted_window_dimsscatter_dims_to_operand_dimsoperand_batching_dimsscatter_indices_batching_dims)rrr)*r rr is_weakly_typed safe_to_castwarningswarnrnumpy_dtype_promotionvalue FutureWarningr tree_unflatten to_gatherrtypeofshardingis_empty_shape slice_shaperr# broadcast_tor5slice_shardingsqueeze newaxis_dimsreversed_y_dimsrevscalar_bool_dims expand_dimsrScatterDimensionNumbersdnums offset_dimscollapsed_slice_dimsstart_index_maprEstart_indices_batching_dimsgather_indicesrr_convert_element_type)r6r8r:rrrrrr r weak_typegeneral_indexerr9r]outs r<r2r2^s+ ))A,%$$Q')   Q " MMIIaL>CIIaL>:##)#?#?#E#E"FG== ,,WkB/  % %dkk!n&=&=Qb % c' ,,- H 1 $!Q q% 3 34$+$:$:!>!--==")--"K"K  % wq%11G5G));^  #   ++c733 4C " "3y 99r>c<|tjury|tjury|tjurb|tj k(ryt j |tjrt j|jStdS|tjurc|tj k(ryt j |tjrt j|jStd Std|)zCGet an appropriate identity for a given operation in a given dtype.rTinfFzUnrecognized op: )r scatter_add scatter_mul scatter_minr bool_r(r'r)r*r,float scatter_maxr+ ValueError)oprs r< _get_identityrrs7    W   W        5"** - \\% $ $$ < W        5"** - \\% $ $$ %L= (- ..r>c Zt|||| tjjn| } t j |}t j |}|j } |tj|dz}tj|d}||dkr td|Ft j|f|jddzt|| | } t| |||||d| S|Jt!j"|j$|} t j| |f|jddzt|| | } t| tj&t j(|jd|z|dddff||||d| } || dj+| S) Nrhz&segment_sum() `num_segments` argument.rz"num_segments must be non-negative.rF)r rr@)rrGatherScatterMode FILL_OR_DROPr#r$rr'r,rconcrete_dim_or_errorrpfullr/rrr=r ceil_of_ratiosize index_exparangeastype) namedata segment_idsr num_segmentsrr bucket_sizereducerrrrf num_bucketss r<_segment_updaters$k*37< " " / /T$ T $ K(+ **%66+&*L++L:bc,,"2 9 :: ((L?TZZ^3 U35 BC  ;j*<D ::   "";#3#3[A+ +|,tzz!"~=z51 @#cjj!2!21!56+E!$'*+ ,*(e$  8# 1  $ $U ++r>c dtd||tj||||tj| S)aDComputes the sum within segments of an array. Similar to TensorFlow's `segment_sum `_ Args: data: an array with the values to be summed. segment_ids: an array with integer dtype that indicates the segments of `data` (along its leading axis) to be summed. Values can be repeated and need not be sorted. num_segments: optional, an int with nonnegative value indicating the number of segments. The default is set to be the minimum number of segments that would support all indices in ``segment_ids``, calculated as ``max(segment_ids) + 1``. Since `num_segments` determines the size of the output, a static value must be provided to use ``segment_sum`` in a JIT-compiled function. indices_are_sorted: whether ``segment_ids`` is known to be sorted. unique_indices: whether `segment_ids` is known to be free of duplicates. bucket_size: size of bucket to group indices into. ``segment_sum`` is performed on each bucket separately to improve numerical stability of addition. Default ``None`` means no bucketing. mode: a :class:`jax.lax.GatherScatterMode` value describing how out-of-bounds indices should be handled. By default, values outside of the range [0, num_segments) are dropped and do not contribute to the sum. Returns: An array with shape :code:`(num_segments,) + data.shape[1:]` representing the segment sums. Examples: Simple 1D segment sum: >>> data = jnp.arange(5) >>> segment_ids = jnp.array([0, 0, 1, 1, 2]) >>> segment_sum(data, segment_ids) Array([1, 5, 4], dtype=int32) Using JIT requires static `num_segments`: >>> from jax import jit >>> jit(segment_sum, static_argnums=2)(data, segment_ids, 3) Array([1, 5, 4], dtype=int32) segment_sumr)rrrjrsumr~rrrrrrs r<rrs4d T;(;(;\.+z~~D RRr>c dtd||tj||||tj| S)aXComputes the product within segments of an array. Similar to TensorFlow's `segment_prod `_ Args: data: an array with the values to be reduced. segment_ids: an array with integer dtype that indicates the segments of `data` (along its leading axis) to be reduced. Values can be repeated and need not be sorted. num_segments: optional, an int with nonnegative value indicating the number of segments. The default is set to be the minimum number of segments that would support all indices in ``segment_ids``, calculated as ``max(segment_ids) + 1``. Since `num_segments` determines the size of the output, a static value must be provided to use ``segment_prod`` in a JIT-compiled function. indices_are_sorted: whether ``segment_ids`` is known to be sorted. unique_indices: whether `segment_ids` is known to be free of duplicates. bucket_size: size of bucket to group indices into. ``segment_prod`` is performed on each bucket separately to improve numerical stability. Default ``None`` means no bucketing. mode: a :class:`jax.lax.GatherScatterMode` value describing how out-of-bounds indices should be handled. By default, values outside of the range [0, num_segments) are dropped and do not contribute to the result. Returns: An array with shape :code:`(num_segments,) + data.shape[1:]` representing the segment products. Examples: Simple 1D segment product: >>> data = jnp.arange(6) >>> segment_ids = jnp.array([0, 0, 1, 1, 2, 2]) >>> segment_prod(data, segment_ids) Array([ 0, 6, 20], dtype=int32) Using JIT requires static `num_segments`: >>> from jax import jit >>> jit(segment_prod, static_argnums=2)(data, segment_ids, 3) Array([ 0, 6, 20], dtype=int32) segment_prodr)rrrkrprodrs r<rrs4d dK)<)c dtd||tj||||tj| S)a#Computes the maximum within segments of an array. Similar to TensorFlow's `segment_max `_ Args: data: an array with the values to be reduced. segment_ids: an array with integer dtype that indicates the segments of `data` (along its leading axis) to be reduced. Values can be repeated and need not be sorted. num_segments: optional, an int with nonnegative value indicating the number of segments. The default is set to be the minimum number of segments that would support all indices in ``segment_ids``, calculated as ``max(segment_ids) + 1``. Since `num_segments` determines the size of the output, a static value must be provided to use ``segment_max`` in a JIT-compiled function. indices_are_sorted: whether ``segment_ids`` is known to be sorted. unique_indices: whether `segment_ids` is known to be free of duplicates. bucket_size: size of bucket to group indices into. ``segment_max`` is performed on each bucket separately. Default ``None`` means no bucketing. mode: a :class:`jax.lax.GatherScatterMode` value describing how out-of-bounds indices should be handled. By default, values outside of the range [0, num_segments) are dropped and do not contribute to the result. Returns: An array with shape :code:`(num_segments,) + data.shape[1:]` representing the segment maximums. Examples: Simple 1D segment max: >>> data = jnp.arange(6) >>> segment_ids = jnp.array([0, 0, 1, 1, 2, 2]) >>> segment_max(data, segment_ids) Array([1, 3, 5], dtype=int32) Using JIT requires static `num_segments`: >>> from jax import jit >>> jit(segment_max, static_argnums=2)(data, segment_ids, 3) Array([1, 3, 5], dtype=int32) segment_maxr)rrrorr,rs r<rrE4b T;(;(;\.+z~~D RRr>c dtd||tj||||tj| S)a#Computes the minimum within segments of an array. Similar to TensorFlow's `segment_min `_ Args: data: an array with the values to be reduced. segment_ids: an array with integer dtype that indicates the segments of `data` (along its leading axis) to be reduced. Values can be repeated and need not be sorted. num_segments: optional, an int with nonnegative value indicating the number of segments. The default is set to be the minimum number of segments that would support all indices in ``segment_ids``, calculated as ``max(segment_ids) + 1``. Since `num_segments` determines the size of the output, a static value must be provided to use ``segment_min`` in a JIT-compiled function. indices_are_sorted: whether ``segment_ids`` is known to be sorted. unique_indices: whether `segment_ids` is known to be free of duplicates. bucket_size: size of bucket to group indices into. ``segment_min`` is performed on each bucket separately. Default ``None`` means no bucketing. mode: a :class:`jax.lax.GatherScatterMode` value describing how out-of-bounds indices should be handled. By default, values outside of the range [0, num_segments) are dropped and do not contribute to the result. Returns: An array with shape :code:`(num_segments,) + data.shape[1:]` representing the segment minimums. Examples: Simple 1D segment min: >>> data = jnp.arange(6) >>> segment_ids = jnp.array([0, 0, 1, 1, 2, 2]) >>> segment_min(data, segment_ids) Array([0, 2, 4], dtype=int32) Using JIT requires static `num_segments`: >>> from jax import jit >>> jit(segment_min, static_argnums=2)(data, segment_ids, 3) Array([0, 2, 4], dtype=int32) segment_minr)rrrlrr+rs r<rr{rr>)NTN)r6rr7zIndex | tuple[Index, ...]r8rrCallable[..., Array]rboolrrr&slicing.GatherScatterMode | str | Noner rr!zNamedSharding | None)r6rr8rr:ztuple[Any, ...]rrrztree_util.PyTreeDefrrrrrrr r)NFFNNN)r}strr~rrrrrr int | NonerrrrrrrzCallable | Nonerrreturnr)NFFNN)r~rrrrrrrrrrrrrrr)+ __future__rcollections.abcr functoolsrtypingrrIr r'jax._srcrrr r#r r jax._src.laxr rjax._src.numpyrrjax._src.numpy.utilrr jax._src.pjitrjax._src.sharding_implsrjax._src.typingrrrr=r2rrrrrrrr>r<rs"#$! #%?#133 dh9= .4 .4.B.4(,.4>B.4A.4]a.4#7 .4h6:26:.6:'+6:=A6:? 6:TX 6:r/404/4+0.2/3CG',#',!*',!)',#- ', )- ', %) ',",',-',A',MR',X,0+0',*.?C 4R&4R(4R%)4R!% 4R ( 4R = 4R IN 4Rr-1,1(-+/@D 4S'4S)4S&*4S"& 4S ) 4S > 4S JO 4Sr,0+0',*.?C 3R&3R(3R%)3R!% 3R ( 3R = 3R IN 3Rp,0+0',*.?C 3R&3R(3R%)3R!% 3R ( 3R = 3R IN 3Rr>