2Vh5ZddlZddlmcmZddlmZddlm Z dZ dZ dZ dZ dZdZy) N) jax_utilscr| tdt|tr|f}tt |t|k7rtd|t|}|r|t|z }g}|D]<}| |cxkr|ksntd|d||dkr||z}|j |>tt |t|k7rtd|t |}t|}|D]}|r|j|dd||<t|Dcgc] }||vs| }}|||fScc}w)aTurn the `axis` argument to the arguments needed by `broadcast_in_dim`. Args: axis: single int or a tuple of ints for the axis argument. The list of dimensions to reduce or insert. input_shape: the shape of the input as a tuple ints. insert_dims: `False` turns dimensions in `axis` to 1s (use case: reduction along `axis` with `keep_dims=True`). `True`, inserts 1s according to `axis` (use case: `expand_dims`). Returns: A tuple of three lists - The canonical value for `axis`: always a list, negative values have been resolved and values are sorted in ascending order. - The output shape: `input_shape` with 1s at the indices in `axis`, for use as the `shape` argument of `broadcast_in_dim`. - The broadcast dimensions: list of dimensions not in `axis`, for use as the `broadcast_dimensions` argument of `broadcast_in_dim`. z Received `None` value for `axis`zRepeated axis in `axis`: zIn `axis`, axis z) is out of bounds for array of dimension r) ValueError isinstanceintlensetappendsortedlistinsertrange) axis input_shape insert_dims result_dimscanonical_axisa output_shapeibroadcast_dimss L/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/backend/jax/sparse.py$axis_shape_dims_for_broadcast_in_dimr sr& |;<<$w 3t9~T"4TF;<<k"Ks4y N !|q.;."1#& +}.  q5KAa ! 3~ 3~#664^4DEFFN+N $L      1 %LO  "'{!3OAq7NaONO < 77Ps  D4)D4ctj|jj|jj}t |j jdz }tj|j |j g|}tj|j|g|}tj||f|j}|rtj|}|S)auAdd the indices of `x2` to `x1` with zero values. Args: x1: `BCOO` tensor to add indices to. x2: `BCOO` tensor to take the indices to add to x1. sum_duplicates: if `True` calls `bcoo_sum_duplicates` on the output. Returns: a `BCOO` tensor equal to `x1` but with extra zeros at indices in `x2` that were missing in `x1`. )rshape) jnpzerosdatardtyper indices concatenate jax_sparseBCOObcoo_sum_duplicates)x1x2sum_duplicatesx2_zeros concat_axisoutput_indices output_dataoutputs rbcoo_add_indicesr0Csyy 6Hbjj&&'!+K__bjj"**%=KPN//277H"5KHK __k>:"(( KF//7 McBtjfd}|S)aDecorator to add support for `JAXSparse` tensors (including `BCOO`) to a non-zero-preserving element-wise unary operator. There are requirements on the operator for this decorator to work correctly: - The operator must be element-wise - The operator must be unary (one input tensor and one output tensor) - The operator must return a tensor of the same shape. Additional arguments to the function (besides the input tensor) are supported. The returned result is a dense tensor. Args: func: The unary operator to wrap. Returns: Wrapped function that supports `JAXSparse` tensors. cpt|tjr|j}|g|i|S)N)rr% JAXSparsetodense)xargskwargsfuncs rsparse_wrapperz(densifying_unary..sparse_wrapperks3 a-- . AA''''r1 functoolswraps)r9r:s` rdensifying_unaryr>Xs(&__T(( r1cfd}|S)a Decorator to add support for `BCOO` sparse tensors to a zero-preserving element-wise unary operator. There are requirements on the operator for this decorator to work correctly: - The operator must be element-wise - The operator must be unary (one input tensor and one output tensor) - The operator must return a tensor of the same shape, and if it is a `BCOO` tensor, the indices of the result must be the same. Therefore: - Reduction operations are not supported (e.g. `mean`). - Operations for which the result may be dense (e.g. `reciprocal`), or the sparse indices depend on the inputs are not supported (e.g. `clip`). This implies that `func(0)` must be 0. Additional arguments to the function (besides the input tensor) are supported as long as they cannot change the indices of the result. For instance,`round` is supported, but `clip` is not supported as `clip(x, 1.0, 2.0)` would always return a dense tensor. Note that if an input sparse tensor contains zero values, the indices and the zero values are preserved. Args: linear: if `True`, means that the operation is such that `op(a + b) == op(a) + op(b)`. Returns: Wrapped function that supports `BCOO` sparse tensors. cFtjfd}|S)Nct|tjrds!|jstj|}tj|j g|i||j f|jS|g|i|S)Nr)rr%r&unique_indicesr'r!r#r)r6r7r8r9linears rr:zIelementwise_unary..wrap_elementwise_unary..sparse_wrappersy!Z__-a&6&6"66q9A!!&&24262AII>aggA////r1r;)r9r:rCs` rwrap_elementwise_unaryz1elementwise_unary..wrap_elementwise_unarys&   0  0r1)rCrDs` relementwise_unaryrFts<  "!r1cfd}|S)a9Decorator to add support for `JAXSparse` tensors (including `BCOO`) to an element-wise binary operator such that the indices present in the result are are the union of the indices in the two operand. The primary use case for this is the `add` and `subtract` operators. There are requirements on the operator for this decorator to work correctly: - The operator must be element-wise. - The operator must be binary (two input tensors and one output tensor). - Both inputs must be of the same shape or one input must be a scalar. - The output must be of the same shape as the (non scalar) inputs. - The indices of the output must be the union of the indices of the inputs. This implies that func(0, 0) must be 0. As a result, if one operand is dense or a scalar, then the result will be dense. Additional arguments to the function (besides the input tensors) are not supported. Note that if the result of the operation is zero at some indices, including because the operands were zero at these indices, the zeros and indices are preserved. The `BCOO` format is the only supported one in all cases. Other formats are not supported when `use_sparsify` is `False`. Args: use_sparsify: indicates that the JAX `sparsify` transform supports this operation. linear: if `True`, mean that the operation is such that `op(a + b, c) == op(a, c) + op(b, c)` and `op(a, c + d) == op(a, c) + op(a, d)`. Returns: Wrapped function that supports `JAXSparse`. c~rtjndtjfd}|S)NcVt|tjrt|tjr|j|jurt|tjrt|tjrs6|j s*tj |}tj |}tj|j|j|jf|j|j|j Sr ||St|tjrt|tjrht|| }t|| }tj|j|j|jf|jddStd|jd|jn;|j}n*t|tjr|j}||S)Nrindices_sortedrBr*TUnsupported sparse format: z and )rr%r4r#r&rBr'r!rrKr0r __class__r5)r(r)r9rC sparse_func use_sparsifys rr:zWelementwise_binary_union..wrap_elementwise_binary_union..sparse_wrappers"j223b*"6"67  bjj0&r:??;&r:??;%b.?.?!+!?!?!CB!+!?!?!CB)!"''2773RZZ@"$((+-+<+<+-+<+<   &*2r22#B 8ZJOO>.b"ZP-b"ZP)!"''2773RZZ@"$((+/+/  #9!||nE",,A BB 4 45ZZ\B< r1r%sparsifyr<r=)r9r:rOrCrPs` @rwrap_elementwise_binary_unionz?elementwise_binary_union..wrap_elementwise_binary_unions;3?j))$/T  ,  , \r1rE)rCrPrSs`` relementwise_binary_unionrTsJ2h )(r1cptjtjfd}|S)aWDecorator to add support for `BCOO` sparse tensors to element-wise binary division and related operators. This decorator is designed for operations related to the division of two two operands (e.g. `divide`). It accepts `BCOO` tensors for both the dividend and the divisor, but handles them differently based on whether they are the dividend or the divisor. - If the divisor is sparse, it is densified and the result is dense because the result contains Inf or Nan outside of the indices of the dividend. - If the dividend is sparse and the divisor is dense, it finds occurrences of zeros and NaNs in the divisor. The result may therefore have more indices than there were in the dividend to return correct values where the divisor was zero or NaN. - If the dividend is sparse and the divisor is a scalar, it does the division element-wise. Note that the result is incorrectly sparse if the scalar divisor is zero. Args: func: The function to wrap. Returns: Wrapped function that supports `BCOO` sparse tensors. c"t|tjrt|tjr"|j}|j}nt|tjrRt |drt |jdk(rTtj|j||jf|j|j|jStj|stj|d}tj |j"tj$s)tj&|tj(|}tj*||j,|j.|jj"}t1||d}||St3d|j4t|tjr|j}||S)NrrrJ)n_batchn_dense index_dtypeTrLrM)rr%r4r5r&hasattrr rr!r#rKrBris_in_jax_tracing_scoperequal issubdtyper"integer logical_orisnanbcoo_fromdenserWrXr0rrN)r(r)x2_zeros_and_nansr9rOs rr:z,elementwise_division..sparse_wrappers b*.. /"j223ZZ\ZZ\B 0r7+s288}/A%??bggr*BJJ7 hh')'8'8')'8'8 %<r||n!MNN J00 1BB|r1rQ)r9r:rOs` @relementwise_divisionrcs90%%d+K__T,,\ r1)r<jax.experimental.sparse experimentalsparser% jax.numpynumpyrkeras.src.utilsrrr0r>rFrTrcrEr1rrjs7,,%78t*8,"^Y)xIr1