VpfLDddlmZddlmZmZddlmZddlZddlZ ddl m Z ddl m Z ddl mZddl mZdd l mZddlm Zdd lmZdd lmZdd lmZmZdd lmZmZddlmZee zeezezezdzZ!ee!e"e!dffZ#ee$e%ee j&fZ' d-dZ(dZ)dZ* d.d/d(Z+ d0d1d)Z, d0d1d*Z- d0d1d+Z. d0d1d,Z/dS)2) annotations)CallableSequence)UnionN)lax)config)core)dtypes)util) lax_numpy) reductions)check_arraylikepromote_dtypes)Array ArrayLike) EllipsisType.Tc tj|}t|trt j|jtjrdt j|jj |cxkr"t j|jj krnntj||j}ntj|}tj ||j \}} } 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)jnpasarray isinstanceintnp issubdtyperintegeriinfominmax_split_index_for_jitshape _scatter_impl) xidxy scatter_opindices_are_sortedunique_indicesmodenormalize_indicestreedef static_idx dynamic_idxs T/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/ops/scatter.py_scatter_updater/,s, k!nn!CR]17BJ??hqwq9999BHQW$5$5$999999 AQW%%%AA AA&)%=c17%K%K"':{ q!Z*k)>4( * **c .tj|} tj|} tj||sWt jdtj|dtj|dtjj dttj |||} tj tj|| | } tj| jr|St%||\}}tj|t)| j}tj|| j}| jrtj|| j}| jrtj|| j}tj| jj| jj| jj}||| j ||| j!p|| j"p||}| jrtj|| j}tGj$|| | 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*axis)update_window_dimsinserted_window_dimsscatter_dims_to_operand_dims)r'r(r))%rrr is_weakly_typed safe_to_castwarningswarnrnumpy_dtype_promotionvalue FutureWarningr!_merge_static_and_dynamic_indices_index_to_gatherr!r is_empty_shape slice_shaper broadcast_totuplesqueeze newaxis_dimsreversed_y_dimsrevscalar_bool_dims expand_dimsScatterDimensionNumbersdnums offset_dimscollapsed_slice_dimsstart_index_mapgather_indicesr'r( lax_internal_convert_element_type)r#r%r&r+r,r-r'r(r)r*r weak_typer$indexerrKouts r.r"r"Ts )A,,%$Q'')  Q " " M=IaLL==,/IaLL==#)#?#E===  -gz;OO#  1s3D F F F'  ,-- H 1  $!Q q% 34455! k!'.///! , 7*++A 5 7344A  %}0 ;!(!>   %  wq%1G5G);^    #  5 +c73 4 4C  +C B BBr0c|tjurdS|tjurdS|tjurY|tjkrdSt j|t jrt j |j StdS|tj urZ|tjkrdSt j|t jrt j |j Std Std|)zCGet an appropriate identity for a given operation in a given dtype.rTinfFzUnrecognized op: )r scatter_add scatter_mul scatter_minr bool_rrrrrfloat scatter_maxr ValueError)oprs r. _get_identityr`s3? 1 S_ 1 S_   T s{ + +" Yu   !! << S_   U s{ + +" Yu   !! %LL= --- . ..r0Fnamestrdatar segment_idsr&r num_segments int | Noner'boolr( bucket_sizereducerCallable | Noner)lax.GatherScatterMode | Nonereturnrc dt|||| tjjn| } t j|}t j|}|j} |tj|dz}tj |d}||dkrtd|Mt j |f|j ddzt|| | } t| |||||d| S|Jt!j|j|} t j | |f|j ddzt|| | } t| tjt j|j d|z|dddff||||d| } || d| S) NrVz&segment_sum() `num_segments` argument.rz"num_segments must be non-negative.rF)r*r)r2)rrGatherScatterMode FILL_OR_DROPrrrrrr concrete_dim_or_errorr^fullr!r`r/r ceil_of_ratiosize index_exparangeastype) rarcrdr&rer'r(rhrir)rrT num_bucketss r._segment_updaterxs$k***/3|  + +$ T  $ K((+ *%6+&&*L+L:bcc,,"2"2 9 : :: (L?TZ^3 U335 B B BC  ;j*<D : : ::    ";#3[AA+ +|,tz!""~=z511 @ @ @#cj!21!566+E!$'*+ ,*(e$  8 8 8# 1    $ $U + ++r0c \td||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))rxrrXr sumrcrdrer'r(rhr)s r.rzrz:d T;.+z~D R R RRr0c \td||tj||||tj| S)aComputes 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. Values outside of the range [0, num_segments) are dropped and do not contribute to the result. 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 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 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{)rxrrYr prodr}s r.rrs:f dK,.+zT S S SSr0c \td||tj||||tj| S)aComputes 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. Values outside of the range [0, num_segments) are dropped and do not contribute to the result. 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 sum. 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{)rxrr]r rr}s r.rr8r~r0c \td||tj||||tj| S)aComputes 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. Values outside of the range [0, num_segments) are dropped and do not contribute to the result. 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 sum. 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{)rxrrZr rr}s r.rror~r0)NT)NFFNNN)rarbrcrrdrr&rrerfr'rgr(rgrhrfrirjr)rkrlr)NFFNN)rcrrdrrerfr'rgr(rgrhrfr)rkrlr)0 __future__rcollections.abcrrtypingrr9numpyrjaxrjax._srcrr r r jax._src.laxrPjax._src.numpyr rr jax._src.numpy.utilrrjax._src.typingrrtypesrrslice SingleIndexrCIndexcomplexr\numberScalarr/r"r`rxrzrrrr0r.rs"#"""""........,,,,,,++++++%%%%%%????????,,,,,,,,EkHSM)E1L@4G  k5c!1223 wsBI- .BF"*"*"*"*P2C2C2Cj///404/4+0.2/39=',',',',',X,0+0',*.59 4R4R4R4R4Rr-1,1(-+/6: 5S5S5S5S5St,0+0',*.59 4R4R4R4R4Rr,0+0',*.59 4R4R4R4R4R4R4Rr0