2Vh}ddlZddlZejejej ZejejejZejejejZ ejejejZ ejejejZddZdZdZdZddZddZd Zd Zd Zd Zdd ZdZdZy)NdtypecZ|j}|jdk(r]|jjddk(r!tj||j Stj |jdStjj||}|j||S)Nrr) default_value) shaperankvaluestfconstantrreshapesparseto_dense set_shape)xrx_shapes S/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/backend/tensorflow/sparse.pysparse_to_denser sggG||q 88>>!  !;;}AGG< <::ahh+ + 1M:AKK Hc|j}tj|j||j}|j ||SN)rr SparseTensorindices dense_shaper)rr rs rsparse_with_valuesrs6ggG  61==9AKK Hrc|tj||j}|j|j|Sr)r broadcast_torrr)scalarroutputs r broadcast_scalar_to_sparse_shaper s/ __VV%7%7 8F V\\" Mrc4t|tjrLtjj |tjj tj |Stjj |tj |S)a>Subtraction for `tf.SparseTensor`s. Either `x1` or `x2` or both can be `tf.SparseTensor`s. Args: x1: fist tensor to add. x2: second tensor to add. Returns: The sum of `x1` and `x2`, which is a `tf.SparseTensor` if and only if both `x1` or `x2` are `tf.SparseTensor`s. ) isinstancer rradd map_valuesnegativex1x2s rsparse_subtractr)&sY"boo&yy}}R!5!5bkk2!FGGyy}}RR11rc\tj|tjtj|df|jj |j }tjj||}|tj|||j }tjjtj|}tjj||}|j|j|jfS|j|jdfS)aCompute the indices for the union of the indices of the provided `tf.SparseTensor`s and another set of indices and return the modified values for these indices. Args: x: a `tf.SparseTensor`. indices: another set of indices in the `tf.SparseTensor` format. Returns: A tuple containing: - the indices for the union - `x1` values for the union indices (some zeros were added) - `x2` values for the union indices (some zeros were added) or `None` if `x2_values` was `None`. rN) r rzerosrr rrrr#r$ zeros_liker)r' x2_indices x2_valueszeros2 x1_for_unionr(zeros1 x2_for_unions rsparse_union_indices_and_valuesr38s__ "((:&q)+RYY__= F 99==V,L __ZBNN C%%bmmR8yy}}R0 ##\%8%8,:M:MMM##\%8%8$>>rc: jdtjjd tj|dtj d tjd tj t ff}tj t ff}tjtjtjj||d tj d} fd tjtj |fd fd}5tjtj |fd  fd }nd} ||fS) a,Compute the indices for the union of two `tf.IndexedSlices` and modify the values for these indices. Args: x1: the first `tf.IndexedSlices`. x2_indices: the indices for the second `tf.IndexedSlices`. x2_value: (optional) the values for the second `tf.IndexedSlices`. Returns: A tuple containing: - the indices for the union - `x1` values for the union indices (some zeros were added) - `x2` values for the union indices (some zeros were added) or `None` if `x2_values` was `None`. raxisctj|tjd|dzf}tj|}tjtj |dd|gd}tj||S)Nr5rr6)r scatter_ndrangegatherconcatr,)indices_expanded indices_countr indices_indicesto_union_indicesvalues_with_leading_zerosdim_0 union_indicess rvalues_for_unionzAindexed_slices_union_indices_and_values..values_for_union~s|--  HHQ ) * H  99_mD$&II ]]6!A; ' 0q% !yy24DEErcjSrr r'srz9indexed_slices_union_indices_and_values..s  rc,jSrrG)rEr'x1_indices_countx1_indices_expandedsrrIz9indexed_slices_union_indices_and_values..s !1299 rNcSrr)r.srrIz9indexed_slices_union_indices_and_values..sIrcSrr)rEx2_indices_countx2_indices_expandedr.srrIz9indexed_slices_union_indices_and_values..s$#%5yr) rr expand_dimsrrr: ones_boolsqueezewheremath logical_orcondequal)r'r-r.x1_indices_one_hotx2_indices_one_hotunion_indices_countx1_values_for_union_indicesx2_values_for_union_indicesrCrDrErKrLrOrPs` ` @@@@@@@r'indexed_slices_union_indices_and_valuesr^Wso NN1 E..!<..!<xx 34Q7xx 34Q7#%&  #%&  JJ ##$68JKL M((=1!4 F#%'' !#67 #&(gg HH%': ;  ' #'+# ## rctjjt}tjjt}tjj tjj |dtjj |dfd}fd}tjtjtjd||S)aCompute the indices for the intersection of two `tf.SparseTensor`s and modify the values for these indices. Args: x1: the first `tf.SparseTensor`. x2: the second `tf.SparseTensor`. Returns: A tuple containing: - the indices for the intersection - `x1` values for the intersection indices (some values were removed) - `x2` values for the intersection indices (some values were removed) r8r6c$tjdjjftjtjdj j tjdj j fS)Nrrr)r r+rr int64r rr&srempty_intersectionzBsparse_intersection_indices_and_values..empty_intersectionsX HHa'rxx 8 HHT 1 HHT 1  rc tjjj}tjj t }tjj t }tjj ||}tjj ||}|jtjjtj|jtjjtjjtj|jtjjfSr) r rr rr$zeros_like_int8r#rretaincastr bool) intersectionr1r/mask1mask2intersection_extra_dimr'r(s rnon_empty_intersectionzFsparse_intersection_indices_and_values..non_empty_intersectionsyy(()?P %%or:%%or: fl3 fl3  II  Rrww!? @ G G II  Rrww!? @ G G  rr) r rr$ones_like_int8setsrirQrWrXsize)r'r(ones1ones2rcrmrls`` @r&sparse_intersection_indices_and_valuesrss II  4E II  4E WW11 e"- e"-     77 /0!4 rc  jdtjjd tjjd jd jd tj t ff}tj t ff}tjtjtjj||dtjdfd}  f d}tjtjd||S)aCompute the indices for the intersection of two `tf.IndexedSlices` and modify the values for these indices. Args: x1: the first `tf.IndexedSlices`. x2: the second `tf.IndexedSlices`. Returns: A tuple containing: - the indices for the intersection - `x1` values for the intersection indices (some values were removed) - `x2` values for the intersection indices (some values were removed) rr5r6r8ctjdjjddzjtjdjjddzjfS)Nrar5)r r+r rr)intersection_indicesr'r(srrczJindexed_slices_intersection_indices_and_values..empty_intersections\ HHTBIIOOAB// : HHTBIIOOAB// :  rc fdtjtjfdfd}tjtj  fd fd}||fS)Nctj|tj|f}tj|}tj||Sr)r r:r;r<)r>r?r r@to_intersection_indicesrCrvs rvalues_for_intersectionzoindexed_slices_intersection_indices_and_values..non_empty_intersection..values_for_intersectionsP mm 'O ')ii!5' #99V%<= =rcjSrrGrHsrrIz`indexed_slices_intersection_indices_and_values..non_empty_intersection.. BIIrc,jSrrG)rzr'rKrLsrrIz`indexed_slices_intersection_indices_and_values..non_empty_intersection..+#%5ryyrcjSrrG)r(srrIz`indexed_slices_intersection_indices_and_values..non_empty_intersection..r|rc,jSrrG)rzr(rOrPsrrIz`indexed_slices_intersection_indices_and_values..non_empty_intersection..r~r)r rWrX) x1_values_for_intersectionx2_values_for_intersectionrzrCrvintersection_indices_countr'rKrLr(rOrPs @rrmzNindexed_slices_intersection_indices_and_values..non_empty_intersectionso >&(WW HH%'A B  & "&(WW HH%'A B  & " ! & &  r) rr rQrrr:rRrSrTrU logical_andrWrX) r'r(rYrZrcrmrCrvrrKrLrOrPs `` @@@@@@@r.indexed_slices_intersection_indices_and_valuesrs* NN1 E..!<..!<*003*003#%&  #%&  :: $$%79KLM "$*>!?!B ! ! F 77 +Q/ rcfd}|S)a<Decorator to add support for `tf.SparseTensor` and `tf.IndexedSlices` 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 and contains `default_value` outside of the indices of the input tensor. Args: default_value: The value to use outside of indices. It must be the value that the operator returns for zero values. Returns: Wrapped function that supports `tf.SparseTensor` and `tf.IndexedSlices`. cFtjfd}|S)Nc>t|tjrTt||jg|i|}t |tj |jjSt|tjr|jg|i|}tj|jtj |j}tj|tj|jd|S|g|i|S)Nr5)r"r rrr rrgr IndexedSlicesfillrtensor_scatter_nd_updaterQr)rargskwargs sparse_outputsparse_output_valuesrrfuncs rsparse_wrapperzGdensifying_unary..wrap_densifying_unary..sparse_wrapperBs!R__- 2tAHH6t6v6! '!GGM=+?+?+E+EFAr//0'+AHH'Ft'Fv'F$MMGGM+?+E+EF22BNN199a8:N+D+F+ +r functoolswraps)rrrs` rwrap_densifying_unaryz/densifying_unary..wrap_densifying_unaryAs&   ,  ,(rr)rrs` rdensifying_unaryr,s*0 ! rcBtjfd}|S)aDecorator to add support for `tf.SparseTensor` and `tf.IndexedSlices` 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 `tf.SparseTensor` or `tf.IndexedSlices`, 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: func: The function to wrap. Returns: Wrapped function that supports `tf.SparseTensor` and `tf.IndexedSlices`. cBt|tjr t||jg|i|St|tj r?tj |jg|i||j |jS|g|i|Sr)r"r rrr rrr)rrrrs rrz)elementwise_unary..sparse_wrapperzs a )%aahh)H)H)HI I 2++ ,##QXX///AMM +D+F+ +rrrrs` relementwise_unaryr\s(<__T,, rcfd}|S)aDecorator to add support for `tf.SparseTensor` and `tf.IndexedSlices` to an element-wise binary operator such that the indices present in the result 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. Args: sparse_op: implementation of the operation for `tf.SparseTensor`. Must work if both of the operands are `tf.SparseTensor`s and can optionally work if one of the operand is a `tf.SparseTensor` and the other one is dense tensor, see `densify_mixed`. densify_mixed: if `True`, `sparse_op` does not support a mix of `tf.SparseTensor` and dense tensor or dense tensor with `tf.SparseTensor` and the `tf.SparseTensor` tensor is densified. Returns: Wrapped function that supports `tf.SparseTensor` and `tf.IndexedSlices`. cHtjfd}|S)Nct|tjrt|tjre|j|jur't ||j |j S||}|j |j|Sr t|}nt|drt|jdk(r t||}||St|tjrHr t|}n]t|drt|jdk(r t||}||St|tjrt|tjr|j|jurFtj|j |j |j|jSt||j|j \}}}tj||||jStj|}n/t|tjrtj|}||SNrr)r"r rrrr rrrhasattrlenr rrr^convert_to_tensor) r'r(rrDx1_values_for_unionx2_values_for_union densify_mixedr sparse_ops rrzWelementwise_binary_union..wrap_elementwise_binary_union..sparse_wrappers"boo.b"//2zzRZZ/1RYY : "+2r!2((2% %,R0&r73s288}7I!A"b!IB(R00B0 (,B"2w/3rxx=A3E=b"E$R,,B 0 01b""2"23zzRZZ/!// BII6JJNN D BII )// "// 3 3*NN  --b1BB 0 01))"-B< rr)rrrrs` rwrap_elementwise_binary_unionz?elementwise_binary_union..wrap_elementwise_binary_unions'  ?  ? Brr)rrrs`` relementwise_binary_unionrsHCJ )(rcBtjfd}|S)aDecorator to add support for `tf.SparseTensor` and `tf.IndexedSlices` to an element-wise binary operator such that the indices present in the result are the intersection of the indices in the two operand. The primary use case for this is the `multiply` operator. 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 intersection of the indices of the inputs. This implies that func(0, x) and func(x, 0) must be 0 for any x. As a result, if one operand is dense or a scalar, then the indices are the ones from the other operand. Additional arguments to the function (besides the input tensors) are not supported. Note that if the operands contains zero values at some common indices, the indices and the zero values are preserved. Args: func: The function to wrap. Returns: Wrapped function that supports `tf.SparseTensor` and `tf.IndexedSlices`. c ~t|tjr*t|tjr|j|jur't ||j |j St ||\}}}tj||||j}|j|j|St|drt|jdk(rt ||j |St ||j tj||jSt|tjr|t|drt|jdk(rt |||j St |tj||j|j St|tjrjt|tjr|j|jurFtj|j |j |j|jSt||\}}}tj||||jSt|drt|jdk(r.sparse_wrappersS b"// *"boo.::+-b$ryy"))2LMM?r2F ,22 __,66 F$$RXX.!Mr7+s288}/A-b$ryy"2EFF.DBLLRZZ,HIBOO ,2w'3rxx=A+=)"d2ryy.ABB*R\\"bjj9299EB,, -"b../::+++RYY 2BJJGr2N ,22++66- r7+s288}/A++RYY+RZZ ++RYY "bjj(AB  B,, -2w'3rxx=A+=''RYY'R^^ ''2rzz2BII>JJNN B|rrrs` relementwise_binary_intersectionrs+<__T``D rcBtjfd}|S)aDecorator to add support for `tf.SparseTensor` and `tf.IndexedSlices` to element-wise binary division and related operators. This decorator is designed for operations related to the division of two operands (e.g. `divide`). It accepts `tf.SparseTensor` and `tf.IndexedSlices` 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 a `tf.SparseTensor` or `tf.IndexedSlices`, 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 a `tf.SparseTensor` or `tf.IndexedSlices` 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 a `tf.SparseTensor` or `tf.IndexedSlices` 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 `tf.SparseTensor` and `tf.IndexedSlices`. c ttjr(ttjrttnt drt j dk(rtjStjdtjjjs=tjjtjjfd}fd}tj tj"||Sttjr tnttj$rttj$r,tj&tj&nt drt j dk(r.sparse_wrapper..func_for_x1_indicess/1RYY R0L M rc tj}t|\}}}tj||tj|j }|j j|Sr)r rTr3rrrrr) x2_zeros_and_nan_indicesrDr_rrr'r(x2_zeros_and_nanss rfunc_for_union_indiceszLelementwise_division..sparse_wrapper..func_for_union_indicess3588.sparse_wrapper..func_for_x1_indicessA!// BIIb"**,EFJJNN rc tjtjd}t|\}}}tj|tj ||j S)Nr8r6)r rSrTr^rr<r)rrDrrrr'r(rs rrzLelementwise_division..sparse_wrapper..func_for_union_indicessz35::HH%67b40D 8 )/ "// 3 " "m <*NN  r)r"r rrrrrrr rXas_dtyper is_integerrUrVis_nanrW reduce_anyrrrrtupler;r )r'r(rrrrs`` @rrz,elementwise_division..sparse_wrappersf b"// *"boo.%R($R(r7+s288}/A-b$ryy"2EFF)+Q%;;rxx0;;,.GG,>,>-rww~~b/A-) &*77 &78.+ BOO ,!$B B,, -"b../))"-))"-r7+s288}/A++RYY+RZZ )+Q%;;rxx0;;,.GG,>,>-rww~~b/A-))+ )eArxx}}6M0N)%*77 &78.+ B,, -%%b)BB|rrrs` relementwise_divisionrxs+4__Tyyv rr)F)r tensorflowr partialonesrhrRint8 ones_int8r+ zeros_int8 ones_likernr,rerrr r)r3r^rsrrrrrrrrrrs I  bggRWW 5 I  bggRWW 5 Y  rxxrww 7 """2<JZ1hQh-!`)Xi)XAHVr