BVh/]dZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZddl mZddl mZddl mZddlmZddlmZddlmZddlmZddlmZddlmZej>Zej@Z eddGddejBe jDZ#ejHdgdZ%edge%edejLdGddejNZ(ejRejTe(ejVjXejZe#e(j\ejZe%e(j\ed gd'd!Z/d"Z0e jbe jde jfe jde jhe jde jje jde jle jne jpe jne jre jne jte jne jvde jxde jdde jnde jzde j|diZ?d(d#Z@ejejd$e#eje@d%e#ejejd&e#y))zSparse tensors.N) struct_pb2)pywrap_tensorflow)tf2)composite_tensor) constant_op)dtypes)ops)override_binary_operator)tensor) tensor_shape) tensor_spec) tensor_util) type_spec)type_spec_registry)array_ops_stack) gen_math_ops)gen_sparse_ops)nested_structure_coder)internal) tf_exportzsparse.SparseTensor SparseTensorc"eZdZdZedZdZdejfdZ e dZ e dZ dZ e dejfd Ze d Ze d Ze d Zd Ze dZdZddZedZe dZdZdZdZdZy)raE Represents a sparse tensor. TensorFlow represents a sparse tensor as three separate dense tensors: `indices`, `values`, and `dense_shape`. In Python, the three tensors are collected into a `SparseTensor` class for ease of use. If you have separate `indices`, `values`, and `dense_shape` tensors, wrap them in a `SparseTensor` object before passing to the ops below. Concretely, the sparse tensor `SparseTensor(indices, values, dense_shape)` comprises the following components, where `N` and `ndims` are the number of values and number of dimensions in the `SparseTensor`, respectively: * `indices`: A 2-D int64 tensor of shape `[N, ndims]`, which specifies the indices of the elements in the sparse tensor that contain nonzero values (elements are zero-indexed). For example, `indices=[[1,3], [2,4]]` specifies that the elements with indexes of [1,3] and [2,4] have nonzero values. * `values`: A 1-D tensor of any type and shape `[N]`, which supplies the values for each element in `indices`. For example, given `indices=[[1,3], [2,4]]`, the parameter `values=[18, 3.6]` specifies that element [1,3] of the sparse tensor has a value of 18, and element [2,4] of the tensor has a value of 3.6. * `dense_shape`: A 1-D int64 tensor of shape `[ndims]`, which specifies the dense_shape of the sparse tensor. Takes a list indicating the number of elements in each dimension. For example, `dense_shape=[3,6]` specifies a two-dimensional 3x6 tensor, `dense_shape=[2,3,4]` specifies a three-dimensional 2x3x4 tensor, and `dense_shape=[9]` specifies a one-dimensional tensor with 9 elements. The corresponding dense tensor satisfies: ```python dense.shape = dense_shape dense[tuple(indices[i])] = values[i] ``` By convention, `indices` should be sorted in row-major order (or equivalently lexicographic order on the tuples `indices[i]`). This is not enforced when `SparseTensor` objects are constructed, but most ops assume correct ordering. If the ordering of sparse tensor `st` is wrong, a fixed version can be obtained by calling `tf.sparse.reorder(st)`. Example: The sparse tensor ```python SparseTensor(indices=[[0, 0], [1, 2]], values=[1, 2], dense_shape=[3, 4]) ``` represents the dense tensor ```python [[1, 0, 0, 0] [0, 0, 2, 0] [0, 0, 0, 0]] ``` ct|std|dt|j|j|j S)NzArgument sparse_tensor_value=z1 is neither a SparseTensor nor SparseTensorValue.indicesvalues dense_shape) is_sparse TypeErrorrrrr)clssparse_tensor_values Y/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/sparse_tensor.py from_valuezSparseTensor.from_valuelsX ( ) 56I5JKII JJ #++"))'33 55ctjdd|||g5tj|dtj}tj|d}tj|dtj}t j |}ddd||_||_||_ |_ |jjd}|jjd }|jjd }|jd j|jd |jd j|jd y#1swYxYw) afCreates a `SparseTensor`. Args: indices: A 2-D int64 tensor of shape `[N, ndims]`. values: A 1-D tensor of any type and shape `[N]`. dense_shape: A 1-D int64 tensor of shape `[ndims]`. Raises: ValueError: When building an eager SparseTensor if `dense_shape` is unknown or contains unknown elements (None or -1). Nrr)namedtyperr&rr)r name_scopeconvert_to_tensorrint64rconstant_value_as_shape_indices_values _dense_shape_dense_shape_defaultshape with_rankdimsassert_is_compatible_with)selfrrrdense_shape_default indices_shape values_shapedense_shape_shapes r"__init__zSparseTensor.__init__vs; nw .L M M%%  7g$$V(;f)) M?k'?? L MDMDL#D 3DMM++A.M<<))!,L#))33A6q33L4E4Ea4HIq334E4J4J14MN1 M Ms A9E  E)returnc|jSzrGet the `TensorShape` representing the shape of the dense tensor. Returns: A `TensorShape` object. r2r7s r" get_shapezSparseTensor.get_shapes  $ $$r$c|jS)zThe indices of non-zero values in the represented dense tensor. Returns: A 2-D Tensor of int64 with dense_shape `[N, ndims]`, where `N` is the number of non-zero values in the tensor, and `ndims` is the rank. )r/rAs r"rzSparseTensor.indicess ==r$c|jS)zlThe non-zero values in the represented dense tensor. Returns: A 1-D Tensor of any data type. )r0rAs r"rzSparseTensor.valuess <<r$cDt|j||jS)a Returns a copy of `self` with `values` replaced by `new_values`. This method produces a new `SparseTensor` that has the same nonzero `indices` and same `dense_shape`, but updated values. Args: new_values: The values of the new `SparseTensor`. Needs to have the same shape as the current `.values` `Tensor`. May have a different type than the current `values`. Returns: A `SparseTensor` with identical indices and shape but updated values. Example usage: >>> st = tf.sparse.from_dense([[1, 0, 2, 0], [3, 0, 0, 4]]) >>> tf.sparse.to_dense(st.with_values([10, 20, 30, 40])) # 4 nonzero values )rr/r1)r7 new_valuess r" with_valueszSparseTensor.with_valuess.  z43D3D EEr$c.|jjS)z4The `Operation` that produces `values` as an output.)r0oprAs r"rIzSparseTensor.ops <>> st = tf.SparseTensor( ... indices=[[0, 0], [1, 2]], values=[1, 2], dense_shape=[3, 4]) >>> st.set_shape([3, 4]) Passing a `None` in the new shape allows any value for that axis: >>> st.set_shape([3, None]) An error is raised if an incompatible shape is passed. >>> st.set_shape([1, 4]) Traceback (most recent call last): ... ValueError: Tensor's shape (3, 4) is not compatible with supplied shape [1, 4] When executing in a `tf.function`, or building a model using `tf.keras.Input`, `SparseTensor.set_shape` will *merge* the given `shape` with the current shape of this tensor, and set the tensor's shape to the merged value (see `tf.TensorShape.merge_with` for details): >>> st = tf.keras.Input(shape=[None, None, 3], sparse=True) >>> print(st.shape) (None, None, None, 3) Dimensions set to `None` are not updated: >>> st.set_shape([None, 224, 224, None]) >>> print(st.shape) (None, 224, 224, 3) The main use case for this is to provide additional shape information that cannot be inferred from the graph alone. Caution: `set_shape` ensures that the applied shape is compatible with the existing shape, but it does not check at runtime. Setting incorrect shapes can result in inconsistencies between the statically-known graph and the runtime value of tensors. Args: shape: A `TensorShape` representing the shape of this tensor, a `TensorShapeProto`, a list, a tuple, or None. Raises: ValueError: If `shape` is not compatible with the current shape of this tensor. N) isinstancer TensorShaper2 merge_with)r7r3s r" set_shapezSparseTensor.set_shapes>j e\55 6&&u-e $ 9 9 D DU KDr$c.|jjS)zDThe `Graph` that contains the index, value, and dense_shape tensors.)r/graphrAs r"rSzSparseTensor.graph!s ==  r$cVd|jd|jd|jdS)NzSparseTensor(indices=z , values=z, dense_shape=))r/r0r1rAs r"__repr__zSparseTensor.__repr__&s! t||T%6%6 88r$Nct|j|j|jg||j|\}}}t |||S)aEvaluates this sparse tensor in a `Session`. Calling this method will execute all preceding operations that produce the inputs needed for the operation that produces this tensor. *N.B.* Before invoking `SparseTensor.eval()`, its graph must have been launched in a session, and either a default session must be available, or `session` must be specified explicitly. Args: feed_dict: A dictionary that maps `Tensor` objects to feed values. See `tf.Session.run` for a description of the valid feed values. session: (Optional.) The `Session` to be used to evaluate this sparse tensor. If none, the default session will be used. Returns: A `SparseTensorValue` object. )_eval_using_default_sessionrrrrSSparseTensorValue)r7 feed_dictsessionrrrs r"evalzSparseTensor.eval*sI($? t{{D$4$45y$**$ GV[ Wfk ::r$c&tt||yN)_override_helperr)operatorfuncs r"_override_operatorzSparseTensor._override_operatorCs\8T2r$cBt|j|jSr^)SparseTensorSpecr3r'rAs r" _type_speczSparseTensor._type_specGs DJJ 33r$c|j+|jdk7rtd|d|jdtj|d}t tj ||j S)Nr*z-Expected a shape with 1 dimension. Obtained: z which has z dimensions.r)ndims ValueErrorr dimension_valuerd unknown_shaper')r7r3ranks r"_shape_invariant_to_type_specz*SparseTensor._shape_invariant_to_type_specKss {{5;;!#3 FugN$$)KK= > ??  ' 'a 1D L66t>  N OO ((4##4::+D+D+F GCDLL$++.1c%(m Jr$chtd|j|j|jfDS)zReturns True if this `SparseTensor` was constructed in eager execution. Requires that each individual component of `SparseTensor` (`indices`, `values` and `dense_shape`) is an instance of `EagerTensor`. c3PK|]}t|tj ywr^)rNr EagerTensor.0ts r" z)SparseTensor._is_eager..os%@  1coo&@$&)allrrrrAs r"rqzSparseTensor._is_eagerhs7 @,, T-=-=>@ @@r$NN)__name__ __module__ __qualname____doc__ classmethodr#r<r rOrBpropertyrrrGr OperationrIr'rr3rQrSrVr\ staticmethodrbrerlrorzrqr$r"rr0s!8t55$OL%11%    F2 #--      % %7Lr  8;233 4 4 J  @r$rYr)v1rdztf.SparseTensorSpecceZdZdZddgZedZdejfdZ dZ edZ ed Z ed Z d Zd Zed ZdZdZdZdZdZdZdZdZedZy)rdz2Type specification for a `tf.sparse.SparseTensor`._shape_dtypectSr^rrAs r"zSparseTensorSpec.s\r$Ncltj||_tj||_y)zConstructs a type specification for a `tf.sparse.SparseTensor`. Args: shape: The dense shape of the `SparseTensor`, or `None` to allow any dense shape. dtype: `tf.DType` of values in the `SparseTensor`. N)r as_shaperras_dtyper)r7r3r's r"r<zSparseTensorSpec.__init__s&''.DK//%(DKr$c2|j|jfSr^)rrrAs r" _serializezSparseTensorSpec._serializes KK %%r$c|jS)zBThe `tf.dtypes.DType` specified by this type for the SparseTensor.rrAs r"r'zSparseTensorSpec.dtype ;;r$c|jS)zAThe `tf.TensorShape` specified by this type for the SparseTensor.rrAs r"r3zSparseTensorSpec.shaperr$c|jj}d}tj||gtj tj|g|j tj|gtj gSr^)rrgr TensorSpecrr-r)r7rk num_valuess r"_component_specsz!SparseTensorSpec._component_specsse ;;  DJ D16<<@ |T[[9vv||4 66r$ct|trtj|}|j|j |j gSr^)rNrYrr#rrrr7values r"_to_componentszSparseTensorSpec._to_componentss8%*+%%e,e MM5<<):): ;;r$ctd|Drtjst|St |}|j j |j|_|S)Nc3PK|]}t|tj ywr^)rNrrndarrayr~s r"rz4SparseTensorSpec._from_components..s ;!Jq"** % ;r)rrenabledrYrr2rPr)r7 tensor_listresults r"_from_componentsz!SparseTensorSpec._from_componentssS ;{ ;; KKM  ,,[)f$*$?$?$J$J ++%f! mr$cLtjdtjgSr^)r rrvariantrAs r"_flat_tensor_specsz#SparseTensorSpec._flat_tensor_specss  " "4 8 99r$ctj|}tj|j|j |j tjgS)Nout_type) rr#rserialize_sparserrrrrrs r"_to_tensor_listz SparseTensorSpec._to_tensor_listsF  # #E *E  + + u||U%6%6 ! ""r$c:tj|j}|jj |j dk(rt d|dtj|j|j|jtjgS)NrzLUnbatching a sparse tensor is only supported for rank >= 1. Obtained input: .r) rr.rrrPrgrhrserialize_many_sparserrrr)r7rrs r"_to_batched_tensor_listz(SparseTensorSpec._to_batched_tensor_lists55e6G6GHK {{k*00A5  "G1 & ''  0 0 u||U%6%6 ! ""r$c6tj|d|j}|\}}}|jj}|j d|g|jj r1tj|jtjd}n|jjtd|jjDrtj||jj}t!|jjD]?\}}|j"t%j&|j"|j(||<Atj*|}n|j |gt-|||S)Nrr3r'r&c38K|]}|jduywr^)r)rdims r"rz@SparseTensorSpec._from_compatible_tensor_list..s @ciit# @s)num)rdeserialize_sparserrrgrQis_fully_definedr r,rr-rkanyr5runstack enumeraterrconstantr'stackr) r7rrrrrkpiecesrxrs r"_from_compatible_tensor_listz-SparseTensorSpec._from_compatible_tensor_lists= 33KNDKKPK#. GV[ ;;  D tTl# {{##%)) ++V\\9k ++   & @t{{/?/? @ @&&{ 8H8HIfdkk../I&!S 99 !**399k6G6GH&)I$))&1kTF#  55r$cttj|gj|j|j Sr^)rdr rO concatenaterr)r7 batch_sizes r"_batchzSparseTensorSpec._batchs5   *.::4;;G  r$c|jjdk(r tdt|jdd|jS)Nrz3Unbatching a tensor is only supported for rank >= 1r*)rrgrhrdrrAs r"_unbatchzSparseTensorSpec._unbatchs; {{A L MM DKKOT[[ 99r$c|jSr^rrAs r"_to_legacy_output_typesz(SparseTensorSpec._to_legacy_output_types ;;r$c|jSr^rrAs r"_to_legacy_output_shapesz)SparseTensorSpec._to_legacy_output_shapesrr$ctSr^rrAs r"_to_legacy_output_classesz*SparseTensorSpec._to_legacy_output_classess r$ct|tr||j|jSt|trot|j t jr'||j|j jS|jtj|Std|dt|jd)Nz6Expected SparseTensor or SparseTensorValue. Received: z of type r) rNrr3r'rYrrrrrr#rtyper)r rs r"r#zSparseTensorSpec.from_values%& ekk **%*+ ELL"** -5$$ell&8&899~~l55e<== Nye)=)=(>aA BBr$)rrrr __slots__r value_typerfloat32r<rr'r3rrrrrrrrrrrrrr#rr$r"rdrdys;")12*v~~ )&     6 6<  : :" "6. :  B Br$"convert_to_tensor_or_sparse_tensorcf|tj|}t|trtj |}t|trN|rJ|j |js/td|jd|jj|Stj|||S)aConverts value to a `SparseTensor` or `Tensor`. Args: value: A `SparseTensor`, `SparseTensorValue`, or an object whose type has a registered `Tensor` conversion function. dtype: Optional element type for the returned tensor. If missing, the type is inferred from the type of `value`. name: Optional name to use if a new `Tensor` is created. Returns: A `SparseTensor` or `Tensor` based on `value`. Raises: RuntimeError: If result type is incompatible with `dtype`. z"Sparse dtype mismatch. Requested: z , Actual: r) rrrNrYrr#is_compatible_withr' RuntimeErrorr&r r,)rr'r&s r"rrs"  OOE "E()  # #E *E|$ U--ekk: =ejj\J%%*[[%5%5$68 99 L  uE ==r$c.t|ttfS)aCheck whether `x` is sparse. Check whether an object is a `tf.sparse.SparseTensor` or `tf.compat.v1.SparseTensorValue`. Args: x: A python object to check. Returns: `True` iff `x` is a `tf.sparse.SparseTensor` or `tf.compat.v1.SparseTensorValue`. )rNrrY)xs r"rr3s A &78 99r$ctj|d||||g5}tj|d}tj|d}|jj}|jj}||k7rt d|d|d t |}|,tj||}tj||}tj|||||cd d d S#t$rV}t d|d d jt jD cgc] } t| ncc} wc} d |d }~wwxYw#1swYy xYw) z.Internal helper function for 'sp_t / dense_t'.truediv sp_valuesr(yz*`x` and `y` must have the same dtype, got z != rzInvalid dtype z" in __truediv__. Expected one of {z, z}.N)r r+r,r' base_dtyper_TRUEDIV_TABLEKeyErrorjoinkeysreprrcastrsparse_dense_cwise_div) sp_indicesrsp_shaperr&x_dtypey_dtyper'excrs r"_sparse_dense_truedivrYs_ ~~ I Ix; %%ikBI ac*Aoo((Ggg  G'   4{! - W%e  ##Iu5i   Au %a  0 0Ix -   7+&))n.A.A.CDT!WDDEFc K s=A2E  C)AE ) E2*ED/.EEE  Edivrmulrr^)Dr collectionsnumpyrrtensorflow.core.protobufrtensorflow.pythonrrtensorflow.python.frameworkrrrr r r r r rrrtensorflow.python.opsrrrtensorflow.python.saved_modelrtensorflow.python.typesr tensorflow.python.util.tf_exportrrXr_ NativeObjectCompositeTensorr namedtuplerYregisterBatchableTypeSpecrdregister_codecBuiltInTypeSpecCodec TypeSpecProtoSPARSE_TENSOR_SPEC'register_type_spec_from_value_converterr#rruint8rint8uint16int16uint32float64int32uint64r-bfloat16float16 complex64 complex128rroverride_binary_operator_helperrsparse_dense_cwise_mulrr$r"rs//!83.+@.4331:1.0@,6%@@** .1@@8((*:*J*J@@2@@F +K**+>+OQ# ! "#$56 23HBy22HB4HBV&%%///*22EE2 11"--/1 11'224 345>6>8 :$ LL&.. KK MM6>> LL&.. MM6>> LL&.. MM6>> LL&.. OOT NND NND NND d t*@988))5,9889l988))5,r$