AVhY/ dZddlZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl#m$Z$ddl#m%Z%dZ&d Z'd!Z(e%d"dd#Z)e%d$dd%Z*e%d&dejVdfd'Z,e%d(d)g*ejZd)ej\dd+d, dd.Z/e%d(g*dd/Z0e/jjcd0d1jcd2d1e0_e%d3d4g*ejZd4ej\dd5d6dd7Z2e%d3g*dd8Z3e%d9dd:Z4e4Z5e%d;dd<Z6e6Z7d=Z8d>Z9 dd?Z:d@Z;e%dAdAdBg*ejZdBddCZ<e%dDdDdEg*ejZdEejzddFZ>GdGdHZ?e%dIdJg*ejZdJej\ddKdLe?dddddfdMZ@e%dIg* ddNZAe%dOdOdPg*ejZdPddQZBe%dRg*ejzejddS ddTZDe%dUg* ddVZEe%dUdWg*ejZdWej\ddXdYej\ddZd[ dd\ZFe%d]d^g*ejZd^ej\ddXdY dd_ZGe%d`g* ddaZHe%d`dbg*ejZdbej\ddXdYej\ddZd[ ddcZIe%dddeg*ejZdeej\ddXdY ddfZJe%dgdgdhg*ejZdh ddiZKe%djdjdkg*ejZdkddlZLe%dmdng*ejddo ddpZM ddqZNe%drdrdsg*ejZdsdtZOe%dududvg*ejZdvddwZPe%dxdxdyg*ejZdyddzZQe%d{d|g*ejzejZd|dejfd}ZSe%d{g*ejzejdfd~ZTe%ddg*ejzejZddejfdZUe%dg*ejzejdfdZVddZWe%dddg*ejzejZdddZXe%dgd*ejZd ddZYe%dddg*ejZdddZZe%dddg*ejZdddZ[e%dddg*ejZdddZ\e%dddg*ejZdddZ]e%dg*ejzdZ^ejejdddejddd-fde jfdZ`e%dejz ddZcddZddZedZf ddZg ddZh ddZiGddejZkejejejejejejejejejg ZueuD]Zvekevjevy)zdSparse Tensor Representation. See also `tf.sparse.SparseTensor`. API docstring: tensorflow.sparse N)composite_tensor) constant_op)dtypes)ops) sparse_tensor)tensor)tensor_conversion) tensor_shape) tensor_util) array_ops)array_ops_stack) bincount_ops) check_ops)control_flow_ops) gen_count_ops) gen_math_ops)gen_sparse_ops)math_ops)special_math_ops)*)compat) deprecation)dispatch)nest) tf_inspect)collections_abc)get_canonical_name_for_symbol) tf_exportct|tjrtjj |St|tjs t d|S)aConvert `sp_input` to `SparseTensor` and return it. Args: sp_input: `SparseTensor` or `SparseTensorValue`. Returns: `sp_input` converted to `SparseTensor`. Raises: ValueError: if `sp_input` is neither `SparseTensor` nor `SparseTensorValue`. zInput must be a SparseTensor.) isinstancerSparseTensorValue SparseTensor from_value TypeError)sp_inputs P/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/sparse_ops.py_convert_to_sparse_tensorr'=sL-99:  % % 0 0 :: Hm88 9 3 44 /ct|tr|Dcgc] }t|c}St|tr d|DSt dcc}w)aSConvert `sp_inputs` to `SparseTensor` objects and return them. Args: sp_inputs: `list` or `tuple` of `SparseTensor` or `SparseTensorValue` objects. Returns: `sp_inputs` converted to `SparseTensor` objects. Raises: ValueError: if any item in `sp_inputs` is neither `SparseTensor` nor `SparseTensorValue`. c32K|]}t|ywN)r').0r%s r& z-_convert_to_sparse_tensors..as JH %h / JszInputs must be a list or tuple.)r listr'tupler$) sp_inputsr%s r&_convert_to_sparse_tensorsr1PsL 4 @I JH %h / JJ 5! J JJ344 KsAcpt|tjr&tj||t j St|tjstdj||jt j k(r|Stj|t j S)Nnamedtypez{} must be an integer value)r rintegral_typesrconvert_to_tensorrint64 tensor_libTensorr$formatr5rcast)valuer4s r&_make_int64_tensorr>es|v,,-  T FF E:,, - 188> ?? [[FLL L ufll ++r(zsparse.from_densec tj|d5tj|}tjt j |tj|}tj||}tj|tj}tj|||cdddS#1swYyxYw)a Converts a dense tensor into a sparse tensor. Only elements not equal to zero will be present in the result. The resulting `SparseTensor` has the same dtype and shape as the input. >>> sp = tf.sparse.from_dense([0, 0, 3, 0, 1]) >>> sp.shape.as_list() [5] >>> sp.values.numpy() array([3, 1], dtype=int32) >>> sp.indices.numpy() array([[2], [4]]) Args: tensor: A dense `Tensor` to be converted to a `SparseTensor`. name: Optional name for the op. Returns: The `SparseTensor`. dense_to_sparse)out_typeN)r name_scoper7r where_v2r not_equal zeros_like gather_ndshaperr8rr")rr4indicesvaluesrGs r& from_denserJos. ~~d-.>  " "6 *F  69#7#7#?@BG   1F OOFV\\ :E  % %gvu = >>>s B#CC zsparse.expand_dimsc|jjd}|"tj|jd}|dn|}t j |d|g5t |tjr't j|dtj}n%t |tjs tdtj|dk\|||zd z}tj|j d}tj"|d gtj$ }tj&|j ddgd|g}tj&|j d|gddg}tj(|||gd }tj&|jdg|g} tj&|j|gdg} t jd gd tj$} tj(| | | gd } t+j,||j.| cdddS#1swYyxYw)aReturns a tensor with an length 1 axis inserted at index `axis`. Given a tensor `input`, this operation inserts a dimension of length 1 at the dimension index `axis` of `input`'s shape. The dimension index follows python indexing rules: It's zero-based, a negative index it is counted backward from the end. This operation is useful to: * Add an outer "batch" dimension to a single element. * Align axes for broadcasting. * To add an inner vector length axis to a tensor of scalars. For example: If you have a sparse tensor with shape `[height, width, depth]`: >>> sp = tf.sparse.SparseTensor(indices=[[3,4,1]], values=[7,], ... dense_shape=[10,10,3]) You can add an outer `batch` axis by passing `axis=0`: >>> tf.sparse.expand_dims(sp, axis=0).shape.as_list() [1, 10, 10, 3] The new axis location matches Python `list.insert(axis, 1)`: >>> tf.sparse.expand_dims(sp, axis=1).shape.as_list() [10, 1, 10, 3] Following standard python indexing rules, a negative `axis` counts from the end so `axis=-1` adds an inner most dimension: >>> tf.sparse.expand_dims(sp, axis=-1).shape.as_list() [10, 10, 3, 1] Note: Unlike `tf.expand_dims` this function includes a default value for the `axis`: `-1`. So if `axis is not specified, an inner dimension is added. >>> sp.shape.as_list() [10, 10, 3] >>> tf.sparse.expand_dims(sp).shape.as_list() [10, 10, 3, 1] This operation requires that `axis` is a valid index for `input.shape`, following python indexing rules: ``` -1-tf.rank(input) <= axis <= tf.rank(input) ``` This operation is related to: * `tf.expand_dims`, which provides this functionality for dense tensors. * `tf.squeeze`, which removes dimensions of size 1, from dense tensors. * `tf.sparse.reshape`, which provides more flexible reshaping capability. Args: sp_input: A `SparseTensor`. axis: 0-D (scalar). Specifies the dimension index at which to expand the shape of `input`. Must be in the range `[-rank(sp_input) - 1, rank(sp_input)]`. Defaults to `-1`. name: The name of the output `SparseTensor`. Returns: A `SparseTensor` with the same data as `sp_input`, but its shape has an additional dimension of size 1 added. rN expand_dims default_namerIaxisr3zLaxis must be an integer value in range [-rank(sp_input) - 1, rank(sp_input)]r5rP new_shaperHrI dense_shape)rV get_shaper rGrrBr rr6r7rint32r9r:r$rCrHzerosr8sliceconcatrr"rI) r%rPr4rank column_size new_indexindices_before indices_afterrH shape_before shape_afterrTrGs r&sparse_expand_dimsrcsL    ' ' )! ,$ \ ??8// 0 3D|$ ~~dzJD$--.  " "4fFLL Id j// 0 . //   daitd{Q ?D//("2"23A6Ka 0 EI__X%5%51vDzJNOOH$4$4q$i"bJM M2rminimumrangerr8rr"r stackr ones)rfrgr5r4 diag_size diag_ranges r& sparse_eyerns& ~~d+7NO -!(J7H)1(7I]8$K  ;7I >J  % %%%z:&>QG~~iu5{+ - - - -s BCC z sparse.concat sparse_concat)v1z*concat_dim is deprecated, use axis instead concat_dimFctjd|d|}||}tjd|d|}t||||S)a Concatenates a list of `SparseTensor` along the specified dimension. Concatenation is with respect to the dense versions of each sparse input. It is assumed that each inputs is a `SparseTensor` whose elements are ordered along increasing dimension number. If expand_nonconcat_dim is False, all inputs' shapes must match, except for the concat dimension. If expand_nonconcat_dim is True, then inputs' shapes are allowed to vary among all inputs. The `indices`, `values`, and `shapes` lists must have the same length. If expand_nonconcat_dim is False, then the output shape is identical to the inputs', except along the concat dimension, where it is the sum of the inputs' sizes along that dimension. If expand_nonconcat_dim is True, then the output shape along the non-concat dimensions will be expand to be the largest among all inputs, and it is the sum of the inputs sizes along the concat dimension. The output elements will be resorted to preserve the sort order along increasing dimension number. This op runs in `O(M log M)` time, where `M` is the total number of non-empty values across all inputs. This is due to the need for an internal sort in order to concatenate efficiently across an arbitrary dimension. For example, if `axis = 1` and the inputs are sp_inputs[0]: shape = [2, 3] [0, 2]: "a" [1, 0]: "b" [1, 1]: "c" sp_inputs[1]: shape = [2, 4] [0, 1]: "d" [0, 2]: "e" then the output will be shape = [2, 7] [0, 2]: "a" [0, 4]: "d" [0, 5]: "e" [1, 0]: "b" [1, 1]: "c" Graphically this is equivalent to doing [ a] concat [ d e ] = [ a d e ] [b c ] [ ] [b c ] Another example, if 'axis = 1' and the inputs are sp_inputs[0]: shape = [3, 3] [0, 2]: "a" [1, 0]: "b" [2, 1]: "c" sp_inputs[1]: shape = [2, 4] [0, 1]: "d" [0, 2]: "e" if expand_nonconcat_dim = False, this will result in an error. But if expand_nonconcat_dim = True, this will result in: shape = [3, 7] [0, 2]: "a" [0, 4]: "d" [0, 5]: "e" [1, 0]: "b" [2, 1]: "c" Graphically this is equivalent to doing [ a] concat [ d e ] = [ a d e ] [b ] [ ] [b ] [ c ] [ c ] Args: axis: Dimension to concatenate along. Must be in range [-rank, rank), where rank is the number of dimensions in each input `SparseTensor`. sp_inputs: List of `SparseTensor` to concatenate. name: A name prefix for the returned tensors (optional). expand_nonconcat_dim: Whether to allow the expansion in the non-concat dimensions. Defaulted to False. concat_dim: The old (deprecated) name for axis. expand_nonconcat_dims: alias for expand_nonconcat_dim Returns: A `SparseTensor` with the concatenated output. Raises: TypeError: If `sp_inputs` is not a list of `SparseTensor`. expand_nonconcat_dimsexpand_nonconcat_dimrPrq)rdeprecated_argument_lookupsparse_concat_v2)rPr0r4rtrqrss r&roros[T%??424&0  / /l0: <$ $ +? FFr(c t|}t|dk(r|dS|Dcgc]}|j}}|Dcgc]}|j}}|Dcgc]}|j}}|rt j tj|Dcgc]}tj|ddgc}dd} |Dcgc];}tj| ddk(r|ddn|dzdk(rgn| dzdgd=}}tj||||\} } } |D cgc]} | j}} td|Drp|rCg}t|djD]%|j!t#fd|D'n|dj%}t'fd|D|<nt)j*}td|Dr.s:E4 :sc3JK|]}tj|ywr+r dimension_at_index)r,rGdims r&r-z#sparse_concat_v2..s&+//s;+ #c3JK|]}tj|ywr+r|)r,rGrPs r&r-z#sparse_concat_v2..s&$#  ''t4$#rc3<K|]}|jywr+)is_fully_definedrzs r&r-z#sparse_concat_v2..s.Bs ?Z^ , ?zGAt least one input should be SparseTensor; do you mean to use tf.add()?c36K|]}t|ywr+rrs r&r-z sparse_add_v2..Fs;SC (;rr)r5r4)rr"r!anyr$rr'rr7rIr5 real_dtype base_dtyperrrHrVrWassert_is_compatible_withr broadcast_static_shaperrr sparse_tensor_dense_add)rrrrrr static_shapers @r&rr sj".. 0O0OP. ?A ? ? % && ;QF;;!!$A!!$A%%22==KQI !!!))QXXq}}"#))QXXq}}"+ -)J L KKM++AKKM:33AKKM45KKMCL$$&!))+l  % %j*l KK!^$ a  1 1!))QXX23-- DDr(z sparse.crossc|d}tj|tj}t |\}}}}t j ||||||\}}} tj||| S)aGenerates sparse cross from a list of sparse and dense tensors. For example, if the inputs are * inputs[0]: SparseTensor with shape = [2, 2] [0, 0]: "a" [1, 0]: "b" [1, 1]: "c" * inputs[1]: SparseTensor with shape = [2, 1] [0, 0]: "d" [1, 0]: "e" * inputs[2]: Tensor [["f"], ["g"]] then the output will be: shape = [2, 2] [0, 0]: "a_X_d_X_f" [1, 0]: "b_X_e_X_g" [1, 1]: "c_X_e_X_g" Customized separator "_Y_": >>> inp_0 = tf.constant([['a'], ['b']]) >>> inp_1 = tf.constant([['c'], ['d']]) >>> output = tf.sparse.cross([inp_0, inp_1], separator='_Y_') >>> output.values Args: inputs: An iterable of `Tensor` or `SparseTensor`. name: Optional name for the op. separator: A string added between each string being joined. Defaults to '_X_'. Returns: A `SparseTensor` of type `string`. _X_)rHrIr dense_inputssepr4) rr7rstring_sparse_cross_internal_v2rsparse_cross_v2rr") inputsr4 separatorrHrIrr indices_out values_out shape_outs r& sparse_crossr`syRI##Iv}}=)*CF*K''66<'5'E'E     ($+z9  # #KY GGr(zsparse.cross_hashedc"t|d|||S)aGenerates hashed sparse cross from a list of sparse and dense tensors. For example, if the inputs are * inputs[0]: SparseTensor with shape = [2, 2] [0, 0]: "a" [1, 0]: "b" [1, 1]: "c" * inputs[1]: SparseTensor with shape = [2, 1] [0, 0]: "d" [1, 0]: "e" * inputs[2]: Tensor [["f"], ["g"]] then the output will be: shape = [2, 2] [0, 0]: FingerprintCat64( Fingerprint64("f"), FingerprintCat64( Fingerprint64("d"), Fingerprint64("a"))) [1, 0]: FingerprintCat64( Fingerprint64("g"), FingerprintCat64( Fingerprint64("e"), Fingerprint64("b"))) [1, 1]: FingerprintCat64( Fingerprint64("g"), FingerprintCat64( Fingerprint64("e"), Fingerprint64("c"))) Args: inputs: An iterable of `Tensor` or `SparseTensor`. num_buckets: An `int` that is `>= 0`. output = hashed_value%num_buckets if num_buckets > 0 else hashed_value. hash_key: Integer hash_key that will be used by the `FingerprintCat64` function. If not given, will use a default key. name: Optional name for the op. Returns: A `SparseTensor` of type `int64`. T)r hashed_output num_bucketshash_keyr4)_sparse_cross_internal)rrrr4s r&sparse_cross_hashedrs!N    r(l/{ct|ttfs tdt d|Ds td|Dcgc]}t|t j s|!}}|Dcgc]}t|t j r|!}}|Dcgc]}|j}}|Dcgc]}|j}}|Dcgc]}|j}}tt|D]M}||jtjk7s$tj ||tj"||<Ott|D]M}||jtjk7s$tj ||tj"||<O||||fScc}wcc}wcc}wcc}wcc}w)z#See gen_sparse_ops.sparse_cross_v2.Inputs must be a listc3K|]:}t|tjxst|tj<ywr+r rr"r9r:r,is r&r-z,_sparse_cross_internal_v2..F   ] ' ')M,6q*:K:K,LM AAz*All inputs must be Tensor or SparseTensor.)r r/r.r$rrr"rHrIrVrirr5rrrr<r8)rr sparse_inputsrr%rHrIrs r&rrs FUDM * + ,,     @ AA :a)C)CDa- z!]-G-GHa,/< <(X   <' <,9 :HOO :& :1> ?XH ?& ? V 9a ay&--'--q 6<<8fQi9 \" #EaA - l1ov||Dl1oE &&, .. = : ?s*F,#F,-F1 F1F60F; Gc t|ttfs tdt d|Ds td|Dcgc]}t|t j s|!}}|Dcgc]}t|t j r|!}}|Dcgc]}|j} }|Dcgc]}|j} }|Dcgc]}|j} }|rtjntj} tj} tt| D]]}| |jtjk7s$t!j"| |tj| |<tj} _tt|D]]}||jtjk7s$t!j"||tj||<tj} _t%j&| | | ||||xst(| | | \}}}t j |||Scc}wcc}wcc}wcc}wcc}w)z See gen_sparse_ops.sparse_cross.rc3K|]:}t|tjxst|tj<ywr+rrs r&r-z)_sparse_cross_internal..rrz All inputs must be SparseTensors) rHrIrrrrrrA internal_typer4)r r/r.r$rrr"rHrIrVrr8rrirr5rr<rr_DEFAULT_HASH_KEY)rrrrr4rrrr%rHrIrrArrrrs r&rrs FUDM * + ,,     6 77 :a)C)CDa- z!]-G-GHa,/< <(X   <' <,9 :HOO :& :1> ?XH ?& ?*V\\ (--- V #a ay&--'--q 6<<8fQillm# \" ##aA - l1ov||Dl1ollm# (6'B'B  !,,!  ($+z9  # #KY GGE = : ?s*H:#H:-H? H?I0I  Ictj|j|j|j|}t j |j||jS)aAdds up a SparseTensor and a dense Tensor, using these special rules: (1) Broadcasts the dense side to have the same shape as the sparse side, if eligible; (2) Then, only the dense values pointed to by the indices of the SparseTensor participate in the cwise addition. By the rules, the result is a logical SparseTensor with exactly the same indices and shape, but possibly with different non-zero values. The output of this Op is the resultant non-zero values. Args: sp_t: the SparseTensor operand. dense_t: the dense Tensor operand; must have the same dtype and a broadcast-compatible shape as `sp_t`. Returns: output: the SparseTensor output. )rsparse_dense_cwise_addrHrIrVrr")sp_tdense_tresults r&rrsK(  0 0t{{151A1A7 L&  # #DLL&$:J:J KKr(zsparse.reordersparse_reorderct|}tj|j|j|j |\}}|j jr5|j j}tj|||Stj|j }tj|||}|j|j|S)aReorders a `SparseTensor` into the canonical, row-major ordering. Note that by convention, all sparse ops preserve the canonical ordering along increasing dimension number. The only time ordering can be violated is during manual manipulation of the indices and values to add entries. Reordering does not affect the shape of the `SparseTensor`. For example, if `sp_input` has shape `[4, 5]` and `indices` / `values`: [0, 3]: b [0, 1]: a [3, 1]: d [2, 0]: c then the output will be a `SparseTensor` of shape `[4, 5]` and `indices` / `values`: [0, 1]: a [0, 3]: b [2, 0]: c [3, 1]: d Args: sp_input: The input `SparseTensor`. name: A name prefix for the returned tensors (optional) Returns: A `SparseTensor` with the same shape and non-empty values, but in canonical ordering. Raises: TypeError: If `sp_input` is not a `SparseTensor`. rx)r'rrrHrIrVrWrrrr"r identityrrG)r%r4 reordered_ind reordered_valrV sp_outputs r&rr5sJ'x 0(##   HOOX-A-AN-**,$$&..0K  % %m]K PP$$X%9%9:K**=-+68I' r(zsparse.reshapesparse_reshapect|}tj|tj}t j |d|g5}tj|j|j||\}}tj|}|j|jnd}|K|jj!r0tj"|}|%t%d|D}|dkDrt'd|zt)|}t+j,|jj} t%d|D} | dk(rGd |vrC|j/d} |d| || dzdz} t1| t+j,| z|| <| d k(s | dk(rTd |vrPt+j,|} | | k7rt'd | || fzt3j4|tj}t7j8|t;j<|j>|cdddS#1swYyxYw) aReshapes a `SparseTensor` to represent values in a new dense shape. This operation has the same semantics as `reshape` on the represented dense tensor. The indices of non-empty values in `sp_input` are recomputed based on the new dense shape, and a new `SparseTensor` is returned containing the new indices and new shape. The order of non-empty values in `sp_input` is unchanged. If one component of `shape` is the special value -1, the size of that dimension is computed so that the total dense size remains constant. At most one component of `shape` can be -1. The number of dense elements implied by `shape` must be the same as the number of dense elements originally represented by `sp_input`. For example, if `sp_input` has shape `[2, 3, 6]` and `indices` / `values`: [0, 0, 0]: a [0, 0, 1]: b [0, 1, 0]: c [1, 0, 0]: d [1, 2, 3]: e and `shape` is `[9, -1]`, then the output will be a `SparseTensor` of shape `[9, 4]` and `indices` / `values`: [0, 0]: a [0, 1]: b [1, 2]: c [4, 2]: d [8, 1]: e Args: sp_input: The input `SparseTensor`. shape: A 1-D (vector) int64 `Tensor` specifying the new dense shape of the represented `SparseTensor`. name: A name prefix for the returned tensors (optional) Returns: A `SparseTensor` with the same non-empty values but with indices calculated by the new dense shape. Raises: TypeError: If `sp_input` is not a `SparseTensor`. ValueError: If argument `shape` requests a `SparseTensor` with a different number of elements than `sp_input`. ValueError: If `shape` has more than one inferred (== -1) dimension. rR SparseReshaperxNc3&K|] }|dk( yw)rLN)r,ds r&r-z!sparse_reshape..s!Ga!r'!GsrQz5At most one dimension can be inferred (-1). Found: %sc3$K|]}|du ywr+r)r,r~s r&r-z!sparse_reshape..sDt DsrzCCannot reshape a tensor with %d elements to shape %s (%d elements).) r'rr<rr8rrBrrrHrVr constant_value_as_shapendimsrrGrconstant_valuer ValueErrorr.npprodindexintrconstantrr"r rrI)r%rGr4 reshaped_indreshaped_shapereshaped_shape_constshape_const_by_usernum_implied_by_useroriginal_reshaped_shape in_shape_size num_implied implied_idxnon_implied_idx reshaped_sizes r&rrlsFf'x 0( --V\\ 2% ~~dOhZ826D#1#@#@(..D$B L.'>>uE*>*D*D*P$$&  ( NN + + - (66u=  (!!G3F!GG  "E#$% %!%%9 :gghnn4467mD/CDDk  a';;-33D9 #L[ 1 #K!O$4 5 6 -0 RWW_5 5-7[)  kQ.';; 45 M )5}EFG G%--  6  % %l&/&8&8&I&4 6a262626s G%H88IceZdZdZy)KeywordRequiredcy)NzKeywordRequired()r)selfs r&__repr__zKeywordRequired.__repr__s r(N)__name__ __module__ __qualname__rrr(r&rrsr(rz sparse.split sparse_splitz)split_dim is deprecated, use axis instead split_dimc t|ts td| td| td| tdtjd|d|}t |}t j||j|j|j||\}}}g} td|D]1} | jtj|| || || 3| S) aSplit a `SparseTensor` into `num_split` tensors along `axis`. If the `sp_input.dense_shape[axis]` is not an integer multiple of `num_split` each slice starting from 0:`shape[axis] % num_split` gets extra one dimension. For example, if `axis = 1` and `num_split = 2` and the input is: input_tensor = shape = [2, 7] [ a d e ] [b c ] Graphically the output tensors are: output_tensor[0] = [ a ] [b c ] output_tensor[1] = [ d e ] [ ] Args: keyword_required: Python 2 standin for * (temporary for argument reorder) sp_input: The `SparseTensor` to split. num_split: A Python integer. The number of ways to split. axis: A 0-D `int32` `Tensor`. The dimension along which to split. Must be in range [-rank, rank), where rank is the number of dimensions in the input `SparseTensor`. name: A name for the operation (optional). split_dim: Deprecated old name for axis. Returns: `num_split` `SparseTensor` objects resulting from splitting `value`. Raises: TypeError: If `sp_input` is not a `SparseTensor`. ValueError: If the deprecated `split_dim` and `axis` are both non None. z1Keyword arguments are required for this function.zsp_input is requiredznum_split is requiredzaxis is requiredrPrrxr)r rrrrur'rrrHrIrVrirrr") keyword_requiredr% num_splitrPr4r output_inds output_vals output_shapessparse_tensorsrs r&rrs` $o 6 H II  + ,, , -- \ ' ((  / /k09 ;$ &x 0(!!     //     *+{M. I 6a"";q>;q>#0#3 566 r(c"t||||dS)aHSplit a `SparseTensor` into `num_split` tensors along `axis`. If the `sp_input.dense_shape[axis]` is not an integer multiple of `num_split` each slice starting from 0:`shape[axis] % num_split` gets extra one dimension. For example: >>> indices = [[0, 2], [0, 4], [0, 5], [1, 0], [1, 1]] >>> values = [1, 2, 3, 4, 5] >>> t = tf.sparse.SparseTensor(indices=indices, values=values, ... dense_shape=[2, 7]) >>> tf.sparse.to_dense(t) >>> output = tf.sparse.split(sp_input=t, num_split=2, axis=1) >>> tf.sparse.to_dense(output[0]) >>> tf.sparse.to_dense(output[1]) >>> output = tf.sparse.split(sp_input=t, num_split=2, axis=0) >>> tf.sparse.to_dense(output[0]) >>> tf.sparse.to_dense(output[1]) >>> output = tf.sparse.split(sp_input=t, num_split=2, axis=-1) >>> tf.sparse.to_dense(output[0]) >>> tf.sparse.to_dense(output[1]) Args: sp_input: The `SparseTensor` to split. num_split: A Python integer. The number of ways to split. axis: A 0-D `int32` `Tensor`. The dimension along which to split. Must be in range [-rank, rank), where rank is the number of dimensions in the input `SparseTensor`. name: A name for the operation (optional). Returns: `num_split` `SparseTensor` objects resulting from splitting `value`. Raises: TypeError: If `sp_input` is not a `SparseTensor`. N)r%rrPr4r)r)r%rrPr4s r&sparse_split_v2r+s | x ) $  &&r(z sparse.slice sparse_slicec t|}tj|tj}tj|tj}tj |d|g5}t j|j|j|j|||\}}}tj|||cdddS#1swYyxYw)aSlice a `SparseTensor` based on the `start` and `size`. For example, if the input is input_tensor = shape = [2, 7] [ a d e ] [b c ] Graphically the output tensors are: sparse.slice([0, 0], [2, 4]) = shape = [2, 4] [ a ] [b c ] sparse.slice([0, 4], [2, 3]) = shape = [2, 3] [ d e ] [ ] Args: sp_input: The `SparseTensor` to split. start: 1-D. tensor represents the start of the slice. size: 1-D. tensor represents the size of the slice. name: A name for the operation (optional). Returns: A `SparseTensor` objects resulting from splicing. Raises: TypeError: If `sp_input` is not a `SparseTensor`. SparseSlicerxN) r'rr7rr8rBrrrHrIrVrr")r%startsizer4output_indices output_valuesrs r&rrpsB'x 0(  v|| 4%  tV\\ 2$ ~~dMH:6 4$2@2M2M   3/NM<  % %nm&2 4 4 4 4s ,AC  Csparse_to_densezGCreate a `tf.sparse.SparseTensor` and use `tf.sparse.to_dense` instead.c8tj||||||S)aConverts a sparse representation into a dense tensor. Builds an array `dense` with shape `output_shape` such that ```python # If sparse_indices is scalar dense[i] = (i == sparse_indices ? sparse_values : default_value) # If sparse_indices is a vector, then for each i dense[sparse_indices[i]] = sparse_values[i] # If sparse_indices is an n by d matrix, then for each i in [0, n) dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i] ``` All other values in `dense` are set to `default_value`. If `sparse_values` is a scalar, all sparse indices are set to this single value. Indices should be sorted in lexicographic order, and indices must not contain any repeats. If `validate_indices` is True, these properties are checked during execution. Args: sparse_indices: A 0-D, 1-D, or 2-D `Tensor` of type `int32` or `int64`. `sparse_indices[i]` contains the complete index where `sparse_values[i]` will be placed. output_shape: A 1-D `Tensor` of the same type as `sparse_indices`. Shape of the dense output tensor. sparse_values: A 0-D or 1-D `Tensor`. Values corresponding to each row of `sparse_indices`, or a scalar value to be used for all sparse indices. default_value: A 0-D `Tensor` of the same type as `sparse_values`. Value to set for indices not specified in `sparse_indices`. Defaults to zero. validate_indices: A boolean value. If True, indices are checked to make sure they are sorted in lexicographic order and that there are no repeats. name: A name for the operation (optional). Returns: Dense `Tensor` of shape `output_shape`. Has the same type as `sparse_values`.  default_valuevalidate_indicesr4)rr)sparse_indicesr sparse_valuesrrr4s r&rrs*f  ' '!'   r(zsparse.reduce_maxc x|d}|rhtj|j|j|jt j ||||\}}}tj|||Stj|j|j|jt j ||||S)a Computes `tf.sparse.maximum` of elements across dimensions of a SparseTensor. This is the reduction operation for the elementwise `tf.sparse.maximum` op. This Op takes a SparseTensor and is the sparse counterpart to `tf.reduce_max()`. In particular, this Op also returns a dense `Tensor` if `output_is_sparse` is `False`, or a `SparseTensor` if `output_is_sparse` is `True`. Note: A gradient is not defined for this function, so it can't be used in training models that need gradient descent. Reduces `sp_input` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` has no entries, all dimensions are reduced, and a tensor with a single element is returned. Additionally, the axes can be negative, similar to the indexing rules in Python. The values not defined in `sp_input` don't participate in the reduce max, as opposed to be implicitly assumed 0 -- hence it can return negative values for sparse `axis`. But, in case there are no values in `axis`, it will reduce to 0. See second example below. For example: # 'x' represents [[1, ?, 2] # [?, 3, ?]] # where ? is implicitly-zero. >>> x = tf.sparse.SparseTensor([[0, 0], [0, 2], [1, 1]], [1, 2, 3], [2, 3]) >>> tf.sparse.reduce_max(x) >>> tf.sparse.reduce_max(x, 0) >>> tf.sparse.reduce_max(x, 1) >>> tf.sparse.reduce_max(x, 1, keepdims=True) >>> tf.sparse.reduce_max(x, [0, 1]) # 'y' represents [[-7, ?] # [ 4, 3] # [ ?, ?] >>> y = tf.sparse.SparseTensor([[0, 0,], [1, 0], [1, 1]], [-7, 4, 3], ... [3, 2]) >>> tf.sparse.reduce_max(y, 1) Args: sp_input: The SparseTensor to reduce. Should have numeric type. axis: The dimensions to reduce; list or scalar. If `None` (the default), reduces all dimensions. keepdims: If true, retain reduced dimensions with length 1. output_is_sparse: If true, returns a `SparseTensor` instead of a dense `Tensor` (the default). name: A name for the operation (optional). Returns: The reduced Tensor or the reduced SparseTensor if `output_is_sparse` is True. Frx) rsparse_reduce_max_sparserHrIrVr_ReductionDimsrr"sparse_reduce_maxr%rPkeepdimsoutput_is_sparser4rrrs r&sparse_reduce_max_v2rsNH//    OO   # #Hd 3   )J L  % %j*l KK  ) )ooh-   r(rz-keep_dims is deprecated, use keepdims instead keep_dimsz.reduction_axes is deprecated, use axis insteadreduction_axesc tjd|d|}tjd|d|}|d}tj|j|j |j tj|||S)a. Computes `tf.sparse.maximum` of elements across dimensions of a SparseTensor. This is the reduction operation for the elementwise `tf.sparse.maximum` op. This Op takes a SparseTensor and is the sparse counterpart to `tf.reduce_max()`. In particular, this Op also returns a dense `Tensor` instead of a sparse one. Note: A gradient is not defined for this function, so it can't be used in training models that need gradient descent. Reduces `sp_input` along the dimensions given in `reduction_axes`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `reduction_axes`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `reduction_axes` has no entries, all dimensions are reduced, and a tensor with a single element is returned. Additionally, the axes can be negative, similar to the indexing rules in Python. The values not defined in `sp_input` don't participate in the reduce max, as opposed to be implicitly assumed 0 -- hence it can return negative values for sparse `reduction_axes`. But, in case there are no values in `reduction_axes`, it will reduce to 0. See second example below. For example: # 'x' represents [[1, ?, 2] # [?, 3, ?]] # where ? is implicitly-zero. >>> x = tf.sparse.SparseTensor([[0, 0], [0, 2], [1, 1]], [1, 2, 3], [2, 3]) >>> tf.sparse.reduce_max(x) >>> tf.sparse.reduce_max(x, 0) >>> tf.sparse.reduce_max(x, 1) >>> tf.sparse.reduce_max(x, 1, keepdims=True) >>> tf.sparse.reduce_max(x, [0, 1]) # 'y' represents [[-7, ?] # [ 4, 3] # [ ?, ?] >>> y = tf.sparse.SparseTensor([[0, 0,], [1, 0], [1, 1]], [-7, 4, 3], ... [3, 2]) >>> tf.sparse.reduce_max(y, 1) Args: sp_input: The SparseTensor to reduce. Should have numeric type. axis: The dimensions to reduce; list or scalar. If `None` (the default), reduces all dimensions. keepdims: If true, retain reduced dimensions with length 1. reduction_axes: Deprecated name of `axis`. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced Tensor. rrrPrF) rrurrrHrIrVrrr%rPrrrs r&rr=sT 3 3J4?L(  / />N0> @$ H  ) ))=)=h-x 99r(zsparse.reduce_max_sparserc 6tjd|d|}tjd|d|}|d}tj|j|j |j tj|||\}}}tj|||S)aComputes the max of elements across dimensions of a SparseTensor. This Op takes a SparseTensor and is the sparse counterpart to `tf.reduce_max()`. In contrast to SparseReduceSum, this Op returns a SparseTensor. Note: A gradient is not defined for this function, so it can't be used in training models that need gradient descent. Reduces `sp_input` along the dimensions given in `reduction_axes`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `reduction_axes`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `reduction_axes` has no entries, all dimensions are reduced, and a tensor with a single element is returned. Additionally, the axes can be negative, which are interpreted according to the indexing rules in Python. Args: sp_input: The SparseTensor to reduce. Should have numeric type. axis: The dimensions to reduce; list or scalar. If `None` (the default), reduces all dimensions. keepdims: If true, retain reduced dimensions with length 1. reduction_axes: Deprecated name of axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced SparseTensor. rrrPrF) rrurrrHrIrVrrrr"r%rPrrrrrrs r&rrL 3 3J4?L(  / />N0> @$ H--   HOOX-A-A  ! !(D 18='*j,  # #J L IIr(zsparse.reduce_sumc x|d}|rhtj|j|j|jt j ||||\}}}tj|||Stj|j|j|jt j ||||S)aComputes `tf.sparse.add` of elements across dimensions of a SparseTensor. This is the reduction operation for the elementwise `tf.sparse.add` op. This Op takes a SparseTensor and is the sparse counterpart to `tf.reduce_sum()`. In particular, this Op also returns a dense `Tensor` if `output_is_sparse` is `False`, or a `SparseTensor` if `output_is_sparse` is `True`. Note: if `output_is_sparse` is True, a gradient is not defined for this function, so it can't be used in training models that need gradient descent. Reduces `sp_input` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` has no entries, all dimensions are reduced, and a tensor with a single element is returned. Additionally, the axes can be negative, similar to the indexing rules in Python. For example: # 'x' represents [[1, ?, 1] # [?, 1, ?]] # where ? is implicitly-zero. >>> x = tf.sparse.SparseTensor([[0, 0], [0, 2], [1, 1]], [1, 1, 1], [2, 3]) >>> tf.sparse.reduce_sum(x) >>> tf.sparse.reduce_sum(x, 0) >>> tf.sparse.reduce_sum(x, 1) # Can also use -1 as the axis >>> tf.sparse.reduce_sum(x, 1, keepdims=True) >>> tf.sparse.reduce_sum(x, [0, 1]) Args: sp_input: The SparseTensor to reduce. Should have numeric type. axis: The dimensions to reduce; list or scalar. If `None` (the default), reduces all dimensions. keepdims: If true, retain reduced dimensions with length 1. output_is_sparse: If true, returns a `SparseTensor` instead of a dense `Tensor` (the default). name: A name for the operation (optional). Returns: The reduced Tensor or the reduced SparseTensor if `output_is_sparse` is True. Frx) rsparse_reduce_sum_sparserHrIrVrrrr"sparse_reduce_sumrs r&sparse_reduce_sum_v2r(spH//    OO   # #Hd 3   )J L  % %j*l KK  ) )ooh-   r(r'c tjd|d|}tjd|d|}|d}tj|j|j |j tj|||S)a}Computes `tf.sparse.add` of elements across dimensions of a SparseTensor. This is the reduction operation for the elementwise `tf.sparse.add` op. This Op takes a SparseTensor and is the sparse counterpart to `tf.reduce_sum()`. In particular, this Op also returns a dense `Tensor` instead of a sparse one. Reduces `sp_input` along the dimensions given in `reduction_axes`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `reduction_axes`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `reduction_axes` has no entries, all dimensions are reduced, and a tensor with a single element is returned. Additionally, the axes can be negative, similar to the indexing rules in Python. For example: # 'x' represents [[1, ?, 1] # [?, 1, ?]] # where ? is implicitly-zero. >>> x = tf.sparse.SparseTensor([[0, 0], [0, 2], [1, 1]], [1, 1, 1], [2, 3]) >>> tf.sparse.reduce_sum(x) >>> tf.sparse.reduce_sum(x, 0) >>> tf.sparse.reduce_sum(x, 1) # Can also use -1 as the axis >>> tf.sparse.reduce_sum(x, 1, keepdims=True) >>> tf.sparse.reduce_sum(x, [0, 1]) Args: sp_input: The SparseTensor to reduce. Should have numeric type. axis: The dimensions to reduce; list or scalar. If `None` (the default), reduces all dimensions. keepdims: If true, retain reduced dimensions with length 1. reduction_axes: Deprecated name of `axis`. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced Tensor. rrrPrF) rrurr'rHrIrVrrr!s r&r'r'sr 3 3J4?L(  / />N0> @$ H  ) ))=)=h-x 99r(zsparse.reduce_sum_sparser&c 6tjd|d|}tjd|d|}|d}tj|j|j |j tj|||\}}}tj|||S)aComputes the sum of elements across dimensions of a SparseTensor. This Op takes a SparseTensor and is the sparse counterpart to `tf.reduce_sum()`. In contrast to SparseReduceSum, this Op returns a SparseTensor. Note: A gradient is not defined for this function, so it can't be used in training models that need gradient descent. Reduces `sp_input` along the dimensions given in `reduction_axes`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `reduction_axes`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `reduction_axes` has no entries, all dimensions are reduced, and a tensor with a single element is returned. Additionally, the axes can be negative, which are interpreted according to the indexing rules in Python. Args: sp_input: The SparseTensor to reduce. Should have numeric type. axis: The dimensions to reduce; list or scalar. If `None` (the default), reduces all dimensions. keepdims: If true, retain reduced dimensions with length 1. reduction_axes: Deprecated name of axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced SparseTensor. rrrPrF) rrurr&rHrIrVrrrr"r#s r&r&r&\r$r(zsparse.to_densesparse_tensor_to_densect|}|!tjg|j}t j |j |j|j|||S)aConverts a `SparseTensor` into a dense tensor. For this sparse tensor with three non-empty values: >>> sp_input = tf.sparse.SparseTensor( ... dense_shape=[3, 5], ... values=[7, 8, 9], ... indices =[[0, 1], ... [0, 3], ... [2, 0]]) The output will be a dense `[3, 5]` tensor with values: >>> tf.sparse.to_dense(sp_input).numpy() array([[0, 7, 0, 8, 0], [0, 0, 0, 0, 0], [9, 0, 0, 0, 0]], dtype=int32) Note: Indices must be without repeats. This is only tested if `validate_indices` is `True`. Args: sp_input: The input `SparseTensor`. default_value: Scalar value to set for indices not specified in `sp_input`. Defaults to zero. validate_indices: A boolean value. If `True`, indices are checked to make sure they are sorted in lexicographic order and that there are no repeats. name: A name prefix for the returned tensors (optional). Returns: A dense tensor with shape `sp_input.dense_shape` and values specified by the non-empty values in `sp_input`. Indices not in `sp_input` are assigned `default_value`. Raises: TypeError: If `sp_input` is not a `SparseTensor`. rRr) r'r rYr5rrrHrVrI)r%rrr4s r&r+r+s^V'x 0(OOBhnn=M  ' 'oo!'   r(zsparse.to_indicatorsparse_to_indicatorct|}tj|d|g5}tj|j d}tj tj|dd}tj|j ||j}t||||}t|dd|cdddS#1swYyxYw)aConverts a `SparseTensor` of ids into a dense bool indicator tensor. The last dimension of `sp_input.indices` is discarded and replaced with the values of `sp_input`. If `sp_input.dense_shape = [D0, D1, ..., Dn, K]`, then `output.shape = [D0, D1, ..., Dn, vocab_size]`, where output[d_0, d_1, ..., d_n, sp_input[d_0, d_1, ..., d_n, k]] = True and False elsewhere in `output`. For example, if `sp_input.dense_shape = [2, 3, 4]` with non-empty values: [0, 0, 0]: 0 [0, 1, 0]: 10 [1, 0, 3]: 103 [1, 1, 1]: 150 [1, 1, 2]: 149 [1, 1, 3]: 150 [1, 2, 1]: 121 and `vocab_size = 200`, then the output will be a `[2, 3, 200]` dense bool tensor with False everywhere except at positions (0, 0, 0), (0, 1, 10), (1, 0, 103), (1, 1, 149), (1, 1, 150), (1, 2, 121). Note that repeats are allowed in the input SparseTensor. This op is useful for converting `SparseTensor`s into dense formats for compatibility with ops that expect dense tensors. The input `SparseTensor` must be in row-major order. Args: sp_input: A `SparseTensor` with `values` property of type `int32` or `int64`. vocab_size: A scalar int64 Tensor (or Python int) containing the new size of the last dimension, `all(0 <= sp_input.values < vocab_size)`. name: A name prefix for the returned tensors (optional) Returns: A dense bool indicator tensor representing the indices with specified value. Raises: TypeError: If `sp_input` is not a `SparseTensor`. SparseToIndicatorrTFrN) r'rrBr rGrHfillrMrr"rVsparse_merge_implr+)r% vocab_sizer4 num_entries new_values sp_valuessp_news r&r-r-sb'x 0( ~~d/(< H//("2"23A6K 5 5k1 EtLJ**8+;+;Z+3+?+?AIxJ EF "ee$ H H H Hs BCC z sparse.merge sparse_mergez%No similar op available at this time.c t|||||S)aCombines a batch of feature ids and values into a single `SparseTensor`. The most common use case for this function occurs when feature ids and their corresponding values are stored in `Example` protos on disk. `parse_example` will return a batch of ids and a batch of values, and this function joins them into a single logical `SparseTensor` for use in functions such as `sparse_tensor_dense_matmul`, `sparse_to_dense`, etc. The `SparseTensor` returned by this function has the following properties: - `indices` is equivalent to `sp_ids.indices` with the last dimension discarded and replaced with `sp_ids.values`. - `values` is simply `sp_values.values`. - If `sp_ids.dense_shape = [D0, D1, ..., Dn, K]`, then `output.shape = [D0, D1, ..., Dn, vocab_size]`. For example, consider the following feature vectors: ```python vector1 = [-3, 0, 0, 0, 0, 0] vector2 = [ 0, 1, 0, 4, 1, 0] vector3 = [ 5, 0, 0, 9, 0, 0] ``` These might be stored sparsely in the following Example protos by storing only the feature ids (column number if the vectors are treated as a matrix) of the non-zero elements and the corresponding values: ```python examples = [Example(features={ "ids": Feature(int64_list=Int64List(value=[0])), "values": Feature(float_list=FloatList(value=[-3]))}), Example(features={ "ids": Feature(int64_list=Int64List(value=[1, 4, 3])), "values": Feature(float_list=FloatList(value=[1, 1, 4]))}), Example(features={ "ids": Feature(int64_list=Int64List(value=[0, 3])), "values": Feature(float_list=FloatList(value=[5, 9]))})] ``` The result of calling parse_example on these examples will produce a dictionary with entries for "ids" and "values". Passing those two objects to this function along with vocab_size=6, will produce a `SparseTensor` that sparsely represents all three instances. Namely, the `indices` property will contain the coordinates of the non-zero entries in the feature matrix (the first dimension is the row number in the matrix, i.e., the index within the batch, and the second dimension is the column number, i.e., the feature id); `values` will contain the actual values. `shape` will be the shape of the original matrix, i.e., (3, 6). For our example above, the output will be equal to: ```python SparseTensor(indices=[[0, 0], [1, 1], [1, 3], [1, 4], [2, 0], [2, 3]], values=[-3, 1, 4, 1, 5, 9], dense_shape=[3, 6]) ``` This method generalizes to higher-dimensions by simply providing a list for both the sp_ids as well as the vocab_size. In this case the resulting `SparseTensor` has the following properties: - `indices` is equivalent to `sp_ids[0].indices` with the last dimension discarded and concatenated with `sp_ids[0].values, sp_ids[1].values, ...`. - `values` is simply `sp_values.values`. - If `sp_ids.dense_shape = [D0, D1, ..., Dn, K]`, then `output.shape = [D0, D1, ..., Dn] + vocab_size`. Args: sp_ids: A single `SparseTensor` with `values` property of type `int32` or `int64` or a Python list of such `SparseTensor`s or a list thereof. sp_values: A `SparseTensor` of any type. vocab_size: A scalar `int64` Tensor (or Python int) containing the new size of the last dimension, `all(0 <= sp_ids.values < vocab_size)`. Or a list thereof with `all(0 <= sp_ids[i].values < vocab_size[i])` for all `i`. name: A name prefix for the returned tensors (optional) already_sorted: A boolean to specify whether the per-batch values in `sp_values` are already sorted. If so skip sorting, False by default (optional). Returns: A `SparseTensor` compactly representing a batch of feature ids and values, useful for passing to functions that expect such a `SparseTensor`. Raises: TypeError: If `sp_values` is not a `SparseTensor`. Or if `sp_ids` is neither a `SparseTensor` nor a list thereof. Or if `vocab_size` is not a `Tensor` or a Python int and `sp_ids` is a `SparseTensor`. Or if `vocab_size` is not a or list thereof and `sp_ids` is a list. ValueError: If `sp_ids` and `vocab_size` are lists of different lengths. )r1)sp_idsr5r2r4already_sorteds r&r7r7 s~ 69j$ OOr(c8t|tjst|tjrR|g}t|tj s1t|t jstdt|z|g}nt|tjstdt|zt|tjstdt|z|D]N}t|tj rt|t jr9tdt|zt|t|k7r tdtj|d||g5|Dcgc] }t!|}}t!|}g}|D]j}|j"}|j$t&j(k7r$t+j,|t&j(}|t/j0|dgz }l|D cgc]&} t+j,| t&j((}} |dj2d d d d f} t/j4| g|zd} |j"} t/j4|dj6d d |gd} tj| | | }|r |cd d d St9|}tj|j2|j"| cd d d Scc}wcc} w#1swYy xYw) zGInternal implementation for sparse_merge to avoid deprecation warnings.z5vocab_size has to be a Tensor or Python int. Found %sz9sp_ids has to be a SparseTensor or list thereof. Found %sz?vocab_size has to be a list of Tensors or Python ints. Found %sz1sp_ids and vocab_size have to have equal lengths. SparseMergerQrSrNrL)r rr!r"r9r:numbersIntegralr$typerIterablerrrrBr'rIr5rr8rr<r rMrHr[rVr)r9r5r2r4r:r~ sp_ids_dimidsids_dimxindices_columns_to_preserve new_indicesr4rTr sorted_results r&r1r1ls  778J m((=*XF z:#4#4 5 z7#3#3 4 M:&' ((J fo66 7 !#'<0 11 j/":": ; !#' #34 55 z  "%/W5E5E%F M I    [C O# H II ~~dMFI+>?@FL M ' 3 MF M))4I C6 !!g   V\\ )--6 i##G!4 55c 6 ;EEQ(--6<<0EJE#))"3"3AssF";""$?#@3#FJK!!J  &)"7"7"E*  !1!1:>+<*  # #K$-$6$6x7K7K$L NNr(zsparse.reset_shapesparse_reset_shapec t|}tj|j}tj|j}tj|j }|yt j|d}t jtjdtjt j|tj|}ntj|}|j!j#dt j$|tj}|j!j&G|j!j(dj+|j!j(dt-j.|}|||j!j1r^t3j4|j!j7}t3j8||kst;d|d|d|}n|t=j>tAjBtjD|tjD|g|}t=j>tAjF||g|}tIjJ|||S)a Resets the shape of a `SparseTensor` with indices and values unchanged. If `new_shape` is None, returns a copy of `sp_input` with its shape reset to the tight bounding box of `sp_input`. This will be a shape consisting of all zeros if sp_input has no values. If `new_shape` is provided, then it must be larger or equal in all dimensions compared to the shape of `sp_input`. When this condition is met, the returned SparseTensor will have its shape reset to `new_shape` and its indices and values unchanged from that of `sp_input.` For example: Consider a `sp_input` with shape [2, 3, 5]: [0, 0, 1]: a [0, 1, 0]: b [0, 2, 2]: c [1, 0, 3]: d - It is an error to set `new_shape` as [3, 7] since this represents a rank-2 tensor while `sp_input` is rank-3. This is either a ValueError during graph construction (if both shapes are known) or an OpError during run time. - Setting `new_shape` as [2, 3, 6] will be fine as this shape is larger or equal in every dimension compared to the original shape [2, 3, 5]. - On the other hand, setting new_shape as [2, 3, 4] is also an error: The third dimension is smaller than the original shape [2, 3, 5] (and an `InvalidArgumentError` will be raised). - If `new_shape` is None, the returned SparseTensor will have a shape [2, 3, 4], which is the tight bounding box of `sp_input`. Args: sp_input: The input `SparseTensor`. new_shape: None or a vector representing the new shape for the returned `SparseTensor`. Returns: A `SparseTensor` indices and values unchanged from `sp_input`. Its shape is `new_shape` if that is set. Otherwise it is the tight bounding box of `sp_input` Raises: TypeError: If `sp_input` is not a `SparseTensor`. ValueError: If `new_shape` represents a tensor with a different rank from that of `sp_input` (if shapes are known when graph is constructed). ValueError: If `new_shape` is determined during graph build to have dimension sizes that are too small. OpError: - If `new_shape` has dimension sizes that are too small. - If shapes are not known during graph construction time, and during run time it is found out that the ranks do not match. rrSrRrQzURequested new_shape should have dimension sizes >= sp_input.shape. Found new_shape (z), sp_input.shape (z).)&r'r rrHrIrVrrmaximumrrr8add ones_likerr7rWrJr<r\rKrr rrrarrayrrrrwith_dependenciesr assert_equalrGassert_less_equalrr") r%rT in_indices in_valuesin_shape dim_low_boundoutput_shape_tensoroutput_shape_tensor_constin_shape_consts r&rPrPs@x'x 0(!!("2"23*  1)    4 4 5('' ;M"**1FLL1 ]I$7$7$ABD// :!!#33A6"--(;V\\J$$&++7##%**1-GG     # #A &(!, : :;N O!---/xx 2 2 4 < < >?n VVN&?? @6 89 96->>  ooh'9L)M O@ ->>  & &x1D E F   # #J ;N OOr(zsparse.fill_empty_rowssparse_fill_empty_rowsct|}tj|d|g5tj||jj }t j|j|j|j|\}}}}tj|||j|fcdddS#1swYyxYw)afFills empty rows in the input 2-D `SparseTensor` with a default value. This op adds entries with the specified `default_value` at index `[row, 0]` for any row in the input that does not already have a value. For example, suppose `sp_input` has shape `[5, 6]` and non-empty values: [0, 1]: a [0, 3]: b [2, 0]: c [3, 1]: d Rows 1 and 4 are empty, so the output will be of shape `[5, 6]` with values: [0, 1]: a [0, 3]: b [1, 0]: default_value [2, 0]: c [3, 1]: d [4, 0]: default_value Note that the input may have empty columns at the end, with no effect on this op. The output `SparseTensor` will be in row-major order and will have the same shape as the input. This op also returns an indicator vector such that empty_row_indicator[i] = True iff row i was an empty row. Args: sp_input: A `SparseTensor` with shape `[N, M]`. default_value: The value to fill for empty rows, with the same type as `sp_input.` name: A name prefix for the returned tensors (optional) Returns: sp_ordered_output: A `SparseTensor` with shape `[N, M]`, and with all empty rows filled in with `default_value`. empty_row_indicator: A bool vector of length `N` indicating whether each input row was empty. Raises: TypeError: If `sp_input` is not a `SparseTensor`. SparseFillEmptyRowsrR)rHrIrVrrUN) r'rrBr7rIr5rr`rHrVrr")r%rr4r rempty_row_indicatorunused_reverse_index_maps r&r`r`=sf'x 0( ~~d1H:> @))X__224M"0!F!F!!))$ "&^]$7  & &(( *,? @ @ @ @s B B99Czio.serialize_sparseserialize_sparsect|||S)aSerialize a `SparseTensor` into a 3-vector (1-D `Tensor`) object. Args: sp_input: The input `SparseTensor`. name: A name prefix for the returned tensors (optional). out_type: The `dtype` to use for serialization. Returns: A 3-vector (1-D `Tensor`), with each column representing the serialized `SparseTensor`'s indices, values, and shape (respectively). Raises: TypeError: If `sp_input` is not a `SparseTensor`. )serialize_sparse_v2r%r4rAs r&reres$ Xx 66r(ct|}tj|j|j|j ||S)aSerialize a `SparseTensor` into a 3-vector (1-D `Tensor`) object. Args: sp_input: The input `SparseTensor`. out_type: The `dtype` to use for serialization. name: A name prefix for the returned tensors (optional). Returns: A 3-vector (1-D `Tensor`), with each column representing the serialized `SparseTensor`'s indices, values, and shape (respectively). Raises: TypeError: If `sp_input` is not a `SparseTensor`. r4rA)r'rrerHrIrVr%rAr4s r&rgrgs@"'x 0(  ( (oo   r(zio.serialize_many_sparseserialize_many_sparsect|||S)a`Serialize `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor`. The `SparseTensor` must have rank `R` greater than 1, and the first dimension is treated as the minibatch dimension. Elements of the `SparseTensor` must be sorted in increasing order of this first dimension. The serialized `SparseTensor` objects going into each row of the output `Tensor` will have rank `R-1`. The minibatch size `N` is extracted from `sparse_shape[0]`. Args: sp_input: The input rank `R` `SparseTensor`. name: A name prefix for the returned tensors (optional). out_type: The `dtype` to use for serialization. Returns: A matrix (2-D `Tensor`) with `N` rows and `3` columns. Each column represents serialized `SparseTensor`'s indices, values, and shape (respectively). Raises: TypeError: If `sp_input` is not a `SparseTensor`. )serialize_many_sparse_v2rhs r&rlrls6 "(Hd ;;r(ct|}tj|j|j|j ||S)a`Serialize `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor`. The `SparseTensor` must have rank `R` greater than 1, and the first dimension is treated as the minibatch dimension. Elements of the `SparseTensor` must be sorted in increasing order of this first dimension. The serialized `SparseTensor` objects going into each row of the output `Tensor` will have rank `R-1`. The minibatch size `N` is extracted from `sparse_shape[0]`. Args: sp_input: The input rank `R` `SparseTensor`. out_type: The `dtype` to use for serialization. name: A name prefix for the returned tensors (optional). Returns: A matrix (2-D `Tensor`) with `N` rows and `3` columns. Each column represents serialized `SparseTensor`'s indices, values, and shape (respectively). Raises: TypeError: If `sp_input` is not a `SparseTensor`. rj)r'rrlrHrIrVrks r&rnrns@4'x 0(  - -oo   r(ctj|||\}}}|jd|g|j|gtj|||S)a9Deserialize `SparseTensor` objects. The input `serialized_sparse` must have the shape `[?, ?, ..., ?, 3]` where the last dimension stores serialized `SparseTensor` objects and the other N dimensions (N >= 0) correspond to a batch. The ranks of the original `SparseTensor` objects must all match. When the final `SparseTensor` is created, its rank is the rank of the incoming `SparseTensor` objects plus N; the sparse tensors have been concatenated along new dimensions, one for each batch. The output `SparseTensor` object's shape values for the original dimensions are the max across the input `SparseTensor` objects' shape values for the corresponding dimensions. The new dimensions match the size of the batch. The input `SparseTensor` objects' indices are assumed ordered in standard lexicographic order. If this is not the case, after this step run `SparseReorder` to restore index ordering. For example, if the serialized input is a `[2 x 3]` matrix representing two original `SparseTensor` objects: index = [ 0] [10] [20] values = [1, 2, 3] shape = [50] and index = [ 2] [10] values = [4, 5] shape = [30] then the final deserialized `SparseTensor` will be: index = [0 0] [0 10] [0 20] [1 2] [1 10] values = [1, 2, 3, 4, 5] shape = [2 50] Args: serialized_sparse: The serialized `SparseTensor` objects. The last dimension must have 3 columns. dtype: The `dtype` of the serialized `SparseTensor` objects. rank: (optional) Python int, the rank of the `SparseTensor` objects. name: A name prefix for the returned tensors (optional). Returns: A `SparseTensor` representing the deserialized `SparseTensor` objects. rxN)rdeserialize_sparserrr"serialized_sparser5r\r4r rrs r&rqrqs\r''(95tL..-D$<($  # #NM< PPr(zio.deserialize_many_sparsedeserialize_many_sparsectj|||\}}}|jd|g|j|gtj|||S)aDeserialize and concatenate `SparseTensors` from a serialized minibatch. The input `serialized_sparse` must be a string matrix of shape `[N x 3]` where `N` is the minibatch size and the rows correspond to packed outputs of `serialize_sparse`. The ranks of the original `SparseTensor` objects must all match. When the final `SparseTensor` is created, it has rank one higher than the ranks of the incoming `SparseTensor` objects (they have been concatenated along a new row dimension). The output `SparseTensor` object's shape values for all dimensions but the first are the max across the input `SparseTensor` objects' shape values for the corresponding dimensions. Its first shape value is `N`, the minibatch size. The input `SparseTensor` objects' indices are assumed ordered in standard lexicographic order. If this is not the case, after this step run `sparse.reorder` to restore index ordering. For example, if the serialized input is a `[2, 3]` matrix representing two original `SparseTensor` objects: index = [ 0] [10] [20] values = [1, 2, 3] shape = [50] and index = [ 2] [10] values = [4, 5] shape = [30] then the final deserialized `SparseTensor` will be: index = [0 0] [0 10] [0 20] [1 2] [1 10] values = [1, 2, 3, 4, 5] shape = [2 50] Args: serialized_sparse: 2-D `Tensor` of type `string` of shape `[N, 3]`. The serialized and packed `SparseTensor` objects. dtype: The `dtype` of the serialized `SparseTensor` objects. rank: (optional) Python int, the rank of the `SparseTensor` objects. name: A name prefix for the returned tensors (optional) Returns: A `SparseTensor` representing the deserialized `SparseTensor`s, concatenated along the `SparseTensor`s' first dimension. All of the serialized `SparseTensor`s must have had the same rank and type. rxN)rrtrrr"rrs r&rtrt4 s^@,, U/..- D$<($  # #NM< PPr(sparse.sparse_dense_matmul)rvz sparse.matmulsparse_tensor_dense_matmulrwc <t|tjst|tjrJ||k7r!t j t ||||St j t ||| | St|}tj|d|j|j|g5}tj|d}tj|j|j|j|||cdddS#1swYyxYw)ai(Multiply SparseTensor (or dense Matrix) (of rank 2) "A" by dense matrix (or SparseTensor) "B". Please note that one and only one of the inputs MUST be a SparseTensor and the other MUST be a dense matrix. The following input format is recommended (but not required) for optimal performance: * If `adjoint_a == false`: `A` should be sorted in lexicographically increasing order. Use `sparse.reorder` if you're not sure. * If `adjoint_a == true`: `A` should be sorted in order of increasing dimension 1 (i.e., "column major" order instead of "row major" order). Args: sp_a: SparseTensor (or dense Matrix) A, of rank 2. b: dense Matrix (or SparseTensor) B, with the same dtype as sp_a. adjoint_a: Use the adjoint of A in the matrix multiply. If A is complex, this is transpose(conj(A)). Otherwise it's transpose(A). adjoint_b: Use the adjoint of B in the matrix multiply. If B is complex, this is transpose(conj(B)). Otherwise it's transpose(B). name: A name prefix for the returned tensors (optional) Returns: A dense matrix (pseudo-code in dense np.matrix notation): `A = A.H if adjoint_a else A` `B = B.H if adjoint_b else B` `return A*B` Notes: Using `tf.nn.embedding_lookup_sparse` for sparse multiplication: It's not obvious but you can consider `embedding_lookup_sparse` as another sparse and dense multiplication. In some situations, you may prefer to use `embedding_lookup_sparse` even though you're not dealing with embeddings. There are two questions to ask in the decision process: Do you need gradients computed as sparse too? Is your sparse data represented as two `SparseTensor`s: ids and values? There is more explanation about data format below. If you answer any of these questions as yes, consider using `tf.nn.embedding_lookup_sparse`. Following explains differences between the expected SparseTensors: For example if dense form of your sparse data has shape `[3, 5]` and values: [[ a ] [b c] [ d ]] `SparseTensor` format expected by `sparse_tensor_dense_matmul`: `sp_a` (indices, values): [0, 1]: a [1, 0]: b [1, 4]: c [2, 2]: d `SparseTensor` format expected by `embedding_lookup_sparse`: `sp_ids` `sp_weights` [0, 0]: 1 [0, 0]: a [1, 0]: 0 [1, 0]: b [1, 1]: 4 [1, 1]: c [2, 0]: 2 [2, 0]: d Deciding when to use `sparse_tensor_dense_matmul` vs. `matmul`(a_is_sparse=True): There are a number of questions to ask in the decision process, including: * Will the SparseTensor `A` fit in memory if densified? * Is the column count of the product large (>> 1)? * Is the density of `A` larger than approximately 15%? If the answer to several of these questions is yes, consider converting the `SparseTensor` to a dense one and using `tf.matmul` with `a_is_sparse=True`. This operation tends to perform well when `A` is more sparse, if the column size of the product is small (e.g. matrix-vector multiplication), if `sp_a.dense_shape` takes on large values. Below is a rough speed comparison between `sparse_tensor_dense_matmul`, labeled 'sparse', and `matmul`(a_is_sparse=True), labeled 'dense'. For purposes of the comparison, the time spent converting from a `SparseTensor` to a dense `Tensor` is not included, so it is overly conservative with respect to the time ratio. Benchmark system: CPU: Intel Ivybridge with HyperThreading (6 cores) dL1:32KB dL2:256KB dL3:12MB GPU: NVidia Tesla k40c Compiled with: `-c opt --config=cuda --copt=-mavx` ``` tensorflow/python/sparse_tensor_dense_matmul_op_test --benchmarks A sparse [m, k] with % nonzero values between 1% and 80% B dense [k, n] % nnz n gpu m k dt(dense) dt(sparse) dt(sparse)/dt(dense) 0.01 1 True 100 100 0.000221166 0.00010154 0.459112 0.01 1 True 100 1000 0.00033858 0.000109275 0.322745 0.01 1 True 1000 100 0.000310557 9.85661e-05 0.317385 0.01 1 True 1000 1000 0.0008721 0.000100875 0.115669 0.01 1 False 100 100 0.000208085 0.000107603 0.51711 0.01 1 False 100 1000 0.000327112 9.51118e-05 0.290762 0.01 1 False 1000 100 0.000308222 0.00010345 0.335635 0.01 1 False 1000 1000 0.000865721 0.000101397 0.117124 0.01 10 True 100 100 0.000218522 0.000105537 0.482958 0.01 10 True 100 1000 0.000340882 0.000111641 0.327506 0.01 10 True 1000 100 0.000315472 0.000117376 0.372064 0.01 10 True 1000 1000 0.000905493 0.000123263 0.136128 0.01 10 False 100 100 0.000221529 9.82571e-05 0.44354 0.01 10 False 100 1000 0.000330552 0.000112615 0.340687 0.01 10 False 1000 100 0.000341277 0.000114097 0.334324 0.01 10 False 1000 1000 0.000819944 0.000120982 0.147549 0.01 25 True 100 100 0.000207806 0.000105977 0.509981 0.01 25 True 100 1000 0.000322879 0.00012921 0.400181 0.01 25 True 1000 100 0.00038262 0.00014158 0.370035 0.01 25 True 1000 1000 0.000865438 0.000202083 0.233504 0.01 25 False 100 100 0.000209401 0.000104696 0.499979 0.01 25 False 100 1000 0.000321161 0.000130737 0.407076 0.01 25 False 1000 100 0.000377012 0.000136801 0.362856 0.01 25 False 1000 1000 0.000861125 0.00020272 0.235413 0.2 1 True 100 100 0.000206952 9.69219e-05 0.46833 0.2 1 True 100 1000 0.000348674 0.000147475 0.422959 0.2 1 True 1000 100 0.000336908 0.00010122 0.300439 0.2 1 True 1000 1000 0.001022 0.000203274 0.198898 0.2 1 False 100 100 0.000207532 9.5412e-05 0.459746 0.2 1 False 100 1000 0.000356127 0.000146824 0.41228 0.2 1 False 1000 100 0.000322664 0.000100918 0.312764 0.2 1 False 1000 1000 0.000998987 0.000203442 0.203648 0.2 10 True 100 100 0.000211692 0.000109903 0.519165 0.2 10 True 100 1000 0.000372819 0.000164321 0.440753 0.2 10 True 1000 100 0.000338651 0.000144806 0.427596 0.2 10 True 1000 1000 0.00108312 0.000758876 0.70064 0.2 10 False 100 100 0.000215727 0.000110502 0.512231 0.2 10 False 100 1000 0.000375419 0.0001613 0.429653 0.2 10 False 1000 100 0.000336999 0.000145628 0.432132 0.2 10 False 1000 1000 0.00110502 0.000762043 0.689618 0.2 25 True 100 100 0.000218705 0.000129913 0.594009 0.2 25 True 100 1000 0.000394794 0.00029428 0.745402 0.2 25 True 1000 100 0.000404483 0.0002693 0.665788 0.2 25 True 1000 1000 0.0012002 0.00194494 1.62052 0.2 25 False 100 100 0.000221494 0.0001306 0.589632 0.2 25 False 100 1000 0.000396436 0.000297204 0.74969 0.2 25 False 1000 100 0.000409346 0.000270068 0.659754 0.2 25 False 1000 1000 0.00121051 0.00193737 1.60046 0.5 1 True 100 100 0.000214981 9.82111e-05 0.456836 0.5 1 True 100 1000 0.000415328 0.000223073 0.537101 0.5 1 True 1000 100 0.000358324 0.00011269 0.314492 0.5 1 True 1000 1000 0.00137612 0.000437401 0.317851 0.5 1 False 100 100 0.000224196 0.000101423 0.452386 0.5 1 False 100 1000 0.000400987 0.000223286 0.556841 0.5 1 False 1000 100 0.000368825 0.00011224 0.304318 0.5 1 False 1000 1000 0.00136036 0.000429369 0.31563 0.5 10 True 100 100 0.000222125 0.000112308 0.505608 0.5 10 True 100 1000 0.000461088 0.00032357 0.701753 0.5 10 True 1000 100 0.000394624 0.000225497 0.571422 0.5 10 True 1000 1000 0.00158027 0.00190898 1.20801 0.5 10 False 100 100 0.000232083 0.000114978 0.495418 0.5 10 False 100 1000 0.000454574 0.000324632 0.714146 0.5 10 False 1000 100 0.000379097 0.000227768 0.600817 0.5 10 False 1000 1000 0.00160292 0.00190168 1.18638 0.5 25 True 100 100 0.00023429 0.000151703 0.647501 0.5 25 True 100 1000 0.000497462 0.000598873 1.20386 0.5 25 True 1000 100 0.000460778 0.000557038 1.20891 0.5 25 True 1000 1000 0.00170036 0.00467336 2.74845 0.5 25 False 100 100 0.000228981 0.000155334 0.678371 0.5 25 False 100 1000 0.000496139 0.000620789 1.25124 0.5 25 False 1000 100 0.00045473 0.000551528 1.21287 0.5 25 False 1000 1000 0.00171793 0.00467152 2.71927 0.8 1 True 100 100 0.000222037 0.000105301 0.47425 0.8 1 True 100 1000 0.000410804 0.000329327 0.801664 0.8 1 True 1000 100 0.000349735 0.000131225 0.375212 0.8 1 True 1000 1000 0.00139219 0.000677065 0.48633 0.8 1 False 100 100 0.000214079 0.000107486 0.502085 0.8 1 False 100 1000 0.000413746 0.000323244 0.781261 0.8 1 False 1000 100 0.000348983 0.000131983 0.378193 0.8 1 False 1000 1000 0.00136296 0.000685325 0.50282 0.8 10 True 100 100 0.000229159 0.00011825 0.516017 0.8 10 True 100 1000 0.000498845 0.000532618 1.0677 0.8 10 True 1000 100 0.000383126 0.00029935 0.781336 0.8 10 True 1000 1000 0.00162866 0.00307312 1.88689 0.8 10 False 100 100 0.000230783 0.000124958 0.541452 0.8 10 False 100 1000 0.000493393 0.000550654 1.11606 0.8 10 False 1000 100 0.000377167 0.000298581 0.791642 0.8 10 False 1000 1000 0.00165795 0.00305103 1.84024 0.8 25 True 100 100 0.000233496 0.000175241 0.75051 0.8 25 True 100 1000 0.00055654 0.00102658 1.84458 0.8 25 True 1000 100 0.000463814 0.000783267 1.68875 0.8 25 True 1000 1000 0.00186905 0.00755344 4.04132 0.8 25 False 100 100 0.000240243 0.000175047 0.728625 0.8 25 False 100 1000 0.000578102 0.00104499 1.80763 0.8 25 False 1000 100 0.000485113 0.000776849 1.60138 0.8 25 False 1000 1000 0.00211448 0.00752736 3.55992 ``` ) adjoint_a adjoint_bSparseTensorDenseMatMulrrx) a_indicesa_valuesa_shaperryrzN)r rr"r!r transposerwr'rrBrHrIr7rsparse_tensor_dense_mat_mulrV)sp_arryrzr4s r&rwrw~ sl=--. =:: ;I  $Qi CEE $Yi- IJJ %T *D 7t{{A6 8 ;?   ,a  7 7LL;;""     s 8ADDzsparse.softmaxsparse_softmaxcHtj|d|j|jg5}t j |j|j|j }tj|j||j cdddS#1swYyxYw)aApplies softmax to a batched N-D `SparseTensor`. The inputs represent an N-D SparseTensor with logical shape `[..., B, C]` (where `N >= 2`), and with indices sorted in the canonical lexicographic order. This op is equivalent to applying the normal `tf.nn.softmax()` to each innermost logical submatrix with shape `[B, C]`, but with the catch that *the implicitly zero elements do not participate*. Specifically, the algorithm is equivalent to: (1) Applies `tf.nn.softmax()` to a densified view of each innermost submatrix with shape `[B, C]`, along the size-C dimension; (2) Masks out the original implicitly-zero locations; (3) Renormalizes the remaining elements. Hence, the `SparseTensor` result has exactly the same non-zero indices and shape. Example using a 3-D SparseTensor: >>> st = tf.sparse.from_dense( ... [[[0., np.e], ... [1., 0.]], ... ... [[np.e, 0.], ... [np.e, np.e]]]) >>> res = tf.sparse.softmax(st) >>> res.indices >>> res.values >>> res.dense_shape >>> tf.sparse.to_dense(res) Args: sp_input: N-D `SparseTensor`, where `N >= 2`. name: optional name of the operation. Returns: output: N-D `SparseTensor` representing the results. SparseSoftmaxN) rrBrHrIrrrVrr")r%r4out_valss r&rro sn ~~dO''9;<>B,,X-=-=x-5-A-ACH  % %h&6&6&.&:&: < <<>> sp_zero = tf.sparse.SparseTensor([[0]], [0], [7]) >>> sp_one = tf.sparse.SparseTensor([[1]], [1], [7]) >>> res = tf.sparse.maximum(sp_zero, sp_one) >>> res.indices >>> res.values >>> res.dense_shape The reduction version of this elementwise operation is `tf.sparse.reduce_max` Args: sp_a: a `SparseTensor` operand whose dtype is real, and indices lexicographically ordered. sp_b: the other `SparseTensor` operand with the same requirements (and the same shape). name: optional name of the operation. Returns: output: the output SparseTensor. SparseSparseMaximumrxN) rrBrHrIrsparse_sparse_maximumrVrr"rsp_br4 out_indices out_valuess r&rr s@ ~~ ! ||T[[$,, <> AE,BB       K   # #KT=M=M NN   AC  Czsparse.minimumsparse_minimumc tj|d|j|j|j|jg5}t j |j|j|j |j|j|j |\}}dddtj|j S#1swY*xYw)avReturns the element-wise min of two SparseTensors. Assumes the two SparseTensors have the same shape, i.e., no broadcasting. Example: >>> sp_zero = tf.sparse.SparseTensor([[0]], [0], [7]) >>> sp_one = tf.sparse.SparseTensor([[1]], [1], [7]) >>> res = tf.sparse.minimum(sp_zero, sp_one) >>> res.indices >>> res.values >>> res.dense_shape Args: sp_a: a `SparseTensor` operand whose dtype is real, and indices lexicographically ordered. sp_b: the other `SparseTensor` operand with the same requirements (and the same shape). name: optional name of the operation. Returns: output: the output SparseTensor. SparseSparseMinimumrxN) rrBrHrIrsparse_sparse_minimumrVrr"rs r&rr s< ~~ ! ||T[[$,, <> AE,BB       K   # #KT=M=M NN  rzsparse.transposesparse_transposectj|d|g5}|||jj4|jj}|dz t j d|dz }n2t j|}|dz tjd|dz }|j}t jt jt j||}tjtj|}|c|jj!rE|jj#}t%|}t'|D] \} } || || <n"|j(} t j| |}t+j,||j.|} t1| } | cdddS#1swYyxYw)a Transposes a `SparseTensor`. Permutes the dimensions according to the value of `perm`. This is the sparse version of `tf.transpose`. The returned tensor's dimension `i` will correspond to the input dimension `perm[i]`. If `perm` is not given, it is set to (n-1...0), where n is the rank of the input tensor. Hence, by default, this operation performs a regular matrix transpose on 2-D input Tensors. For example: >>> x = tf.SparseTensor(indices=[[0, 1], [0, 3], [2, 3], [3, 1]], ... values=[1.1, 2.2, 3.3, 4.4], ... dense_shape=[4, 5]) >>> print('x =', tf.sparse.to_dense(x)) x = tf.Tensor( [[0. 1.1 0. 2.2 0. ] [0. 0. 0. 0. 0. ] [0. 0. 0. 3.3 0. ] [0. 4.4 0. 0. 0. ]], shape=(4, 5), dtype=float32) >>> x_transpose = tf.sparse.transpose(x) >>> print('x_transpose =', tf.sparse.to_dense(x_transpose)) x_transpose = tf.Tensor( [[0. 0. 0. 0. ] [1.1 0. 0. 4.4] [0. 0. 0. 0. ] [2.2 0. 3.3 0. ] [0. 0. 0. 0. ]], shape=(5, 4), dtype=float32) Equivalently, you could call `tf.sparse.transpose(x, perm=[1, 0])`. The `perm` argument is more useful for n-dimensional tensors where n > 2. >>> x = tf.SparseTensor(indices=[[0, 0, 1], [0, 0, 3], [1, 2, 3], [1, 3, 1]], ... values=[1.1, 2.2, 3.3, 4.4], ... dense_shape=[2, 4, 5]) >>> print('x =', tf.sparse.to_dense(x)) x = tf.Tensor( [[[0. 1.1 0. 2.2 0. ] [0. 0. 0. 0. 0. ] [0. 0. 0. 0. 0. ] [0. 0. 0. 0. 0. ]] [[0. 0. 0. 0. 0. ] [0. 0. 0. 0. 0. ] [0. 0. 0. 3.3 0. ] [0. 4.4 0. 0. 0. ]]], shape=(2, 4, 5), dtype=float32) As above, simply calling `tf.sparse.transpose` will default to `perm=[2,1,0]`. To take the transpose of a batch of sparse matrices, where 0 is the batch dimension, you would set `perm=[0,2,1]`. >>> x_transpose = tf.sparse.transpose(x, perm=[0, 2, 1]) >>> print('x_transpose =', tf.sparse.to_dense(x_transpose)) x_transpose = tf.Tensor( [[[0. 0. 0. 0. ] [1.1 0. 0. 0. ] [0. 0. 0. 0. ] [2.2 0. 0. 0. ] [0. 0. 0. 0. ]] [[0. 0. 0. 0. ] [0. 0. 0. 4.4] [0. 0. 0. 0. ] [0. 0. 3.3 0. ] [0. 0. 0. 0. ]]], shape=(2, 5, 4), dtype=float32) Args: sp_input: The input `SparseTensor`. perm: A permutation vector of the dimensions of `sp_input`. name: A name prefix for the returned tensors (optional). Returns: A transposed `SparseTensor`. Raises: TypeError: If `sp_input` is not a `SparseTensor`. SparseTransposeNrQr)rrBrGr\raranger rrirHrrLr rr7rWrrr. enumeraterVrr"rIr) r%permr4r\rHtransposed_indicesperm_ old_shape_transposed_dense_shaperprV transposed_sts r&rr sb ~~d-z:d |    (~~""qBIIaq11~~h'qHNN1dA66G",,,,W5t<>  & &s'<'Applies `op` to the `.values` tensor of one or more `SparseTensor`s. Replaces any `SparseTensor` in `args` or `kwargs` with its `values` tensor (which contains the non-default values for the SparseTensor), and then calls `op`. Returns a `SparseTensor` that is constructed from the input `SparseTensor`s' `indices`, `dense_shape`, and the value returned by the `op`. If the input arguments contain multiple `SparseTensor`s, then they must have equal `indices` and dense shapes. Examples: >>> s = tf.sparse.from_dense([[1, 2, 0], ... [0, 4, 0], ... [1, 0, 0]]) >>> tf.sparse.to_dense(tf.sparse.map_values(tf.ones_like, s)).numpy() array([[1, 1, 0], [0, 1, 0], [1, 0, 0]], dtype=int32) >>> tf.sparse.to_dense(tf.sparse.map_values(tf.multiply, s, s)).numpy() array([[ 1, 4, 0], [ 0, 16, 0], [ 1, 0, 0]], dtype=int32) >>> tf.sparse.to_dense(tf.sparse.map_values(tf.add, s, 5)).numpy() array([[6, 7, 0], [0, 9, 0], [6, 0, 0]], dtype=int32) Note: even though `tf.add(0, 5) != 0`, implicit zeros will remain unchanged. However, if the sparse tensor contains any explicit zeros, these will be affected by the mapping! Args: op: The operation that should be applied to the SparseTensor `values`. `op` is typically an element-wise operation (such as math_ops.add), but any operation that preserves the shape can be used. *args: Arguments for `op`. **kwargs: Keyword arguments for `op`. Returns: A `SparseTensor` whose `indices` and `dense_shape` matches the `indices` and `dense_shape` of all input `SparseTensor`s. Raises: ValueError: If args contains no `SparseTensor`, or if the `indices` or `dense_shape`s of the input `SparseTensor`s are not equal. z.No SparseTensor in argument list of map_valuesrN) _replace_sparse_with_valuesrrcontrol_dependencies_assert_sparse_compatiblerr"rHrV)opargskwargs sparse_list inner_args inner_kwargss r& map_valuesrt sh+*4=*,V[A,  E FF  9+ FGB  % %k!n&<&<&(*&E &E&1!n&@&@ B BBBs 7BBarrc d|dn|}tj|5| |r td|jjs$t j |tj}|d}|dvrtd|dtj|}|dkD} t jt j|jd} t j | |j| d zz} |8tj|d |j }tj|| } |8tj|d |j }tj || } |dk(r| t#|||}|j}t%|t&j(rOt#|||}tj*|j,|j|j.| || cdddSt1j2|||}tj4|| ||cdddS#1swYyxYw)aCounts the number of occurrences of each value in an integer array. Only the values in the SparseTensor's `values` tensor are counted, missing zeros are ignored. If `minlength` and `maxlength` are not given, returns a vector with length `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise. >>> data = tf.sparse.SparseTensor( ... indices=[[0, 3], [1, 7], [2, 4], [3, 0], ... [4, 9], [5, 1], [6, 8], [7, 2]], ... values=[1,1,2,3,2,4,4,5], ... dense_shape=[8, 10]) >>> tf.math.bincount(data) Vector length = Maximum element in vector `values` is 5. Adding 1, which is 6 will be the vector length. Each bin value in the output indicates number of occurrences of the particular index. Here, index 1 in output has a value 2. This indicates value 1 occurs two times in `values`. **Bin-counting with weights** >>> indices=[[0, 3], [1, 7], [2, 4], [3, 0], [4, 9], [5, 1], [6, 8], [7, 2]] >>> data = tf.sparse.SparseTensor( ... indices=indices, ... values=[1,1,2,3,2,4,4,5], ... dense_shape=[8, 10]) >>> weights = tf.sparse.SparseTensor( ... indices=indices, ... values=[1,5,0,1,0,5,4,5], ... dense_shape=[8, 10]) >>> tf.math.bincount(data, weights=weights) When `weights` is specified, bins will be incremented by the corresponding weight instead of 1. Here, index 1 in output has a value 6. This is the summation of `weights` corresponding to the value in `values` (i.e. for index 1, the first two data values are 1 so the first two weights, 1 and 5, are summed). On GPU, `bincount` with weights is only supported when `axis=0` and XLA is enabled (typically when a function decorated with `@tf.function(jit_compile=True)`). **Bin-counting matrix rows independently** This example uses `axis=-1` with a 2 dimensional input and returns a `Tensor` with bincounting where axis 0 is **not** flattened, i.e. an independent bincount for each matrix row. >>> data = tf.sparse.SparseTensor( ... indices=[[0, 3], [0, 7], [1, 4], [1, 0], ... [1, 9], [2, 1], [2, 8], [2, 2]], ... values=[1,1,2,3,2,4,4,5], ... dense_shape=[3, 10]) >>> tf.math.bincount(data, axis=-1) **Bin-counting with binary_output** This example gives binary output instead of counting the occurrence. >>> data = tf.sparse.SparseTensor( ... indices=[[0, 3], [0, 7], [1, 4], [1, 0], ... [1, 9], [2, 1], [2, 8], [2, 2]], ... values=[1,1,2,3,2,4,4,5], ... dense_shape=[3, 10]) >>> tf.math.bincount(data, axis=-1, binary_output=True) **Missing zeros in SparseTensor** Note that missing zeros (implict zeros) in SparseTensor are **NOT** counted. This supports cases such as `0` in the values tensor indicates that index/id `0`is present and a missing zero indicates that no index/id is present. If counting missing zeros is desired, there are workarounds. For the `axis=0` case, the number of missing zeros can computed by subtracting the number of elements in the SparseTensor's `values` tensor from the number of elements in the dense shape, and this difference can be added to the first element of the output of `bincount`. For all cases, the SparseTensor can be converted to a dense Tensor with `tf.sparse.to_dense` before calling `tf.math.bincount`. >>> data = tf.sparse.SparseTensor( ... indices=[[0, 3], [1, 7], [2, 4], [3, 0], ... [4, 9], [5, 1], [6, 8], [7, 2]], ... values=[1,1,2,3,2,4,4,5], ... dense_shape=[8, 10]) >>> counts = tf.math.bincount(data, dtype=tf.int64) >>> dense_size = tf.math.reduce_prod(data.dense_shape) >>> missing_zeros = dense_size - tf.size(data.values, out_type=tf.int64) >>> tf.concat([[counts[0] + missing_zeros], counts[1:]], 0) >>> data = tf.sparse.SparseTensor( ... indices=[[0, 3], [1, 7], [2, 4], [3, 0], ... [4, 9], [5, 1], [6, 8], [7, 2]], ... values=[1,1,2,3,2,4,4,5], ... dense_shape=[8, 10]) >>> tf.math.bincount(tf.sparse.to_dense(data), dtype=tf.int64) Args: arr: A SparseTensor whose values should be counted. These tensors must have a rank of 2 if `axis=-1`. weights: If non-None, must be a SparseTensor with the same dense shape and same indices as `arr`. For each value in `arr`, the bin will be incremented by the corresponding weight instead of 1. If non-None, `binary_output` must be False. minlength: If given, ensures the output has length at least `minlength`, padding with zeros at the end if necessary. maxlength: If given, skips values in `arr` that are equal or greater than `maxlength`, ensuring that the output has length at most `maxlength`. dtype: If `weights` is None, determines the type of the output bins. name: A name scope for the associated operations (optional). axis: The axis to slice over. Axes at and below `axis` will be flattened before bin counting. Currently, only `0`, and `-1` are supported. If None, all axes will be flattened (identical to passing `0`). XLA does not support `axis=-1`. binary_output: If True, this op will output 1 instead of the number of times a token appears (equivalent to one_hot + reduce_any instead of one_hot + reduce_add). Defaults to False. Returns: A vector with the same dtype as `weights` or the given `dtype` containing the bincount values. Raises: `InvalidArgumentError` if negative values are provided as an input. NbincountXArguments `binary_output` and `weights` are mutually exclusive. Please specify only one.rrrL$Unsupported value for argument axis=(. Only 0 and -1 are currently supported.rLrQ minlengthr3 maxlength)rHrIrVr weights binary_output)inputr rr)rrBrr5 is_integerrr<rrXr r rRrrIr7rrhvalidate_sparse_weightsr rr"sparse_bincountrHrVrvalidate_dense_weightsdense_bincount) rrrrr5r4rPr total_sizearray_is_nonempty max_value output_sizes r&rr s n|$ ~~d3'} = >> 99   MM#v|| ,c | d 7 =dVD66 77$J"Q  !4!4SZZ!@"EI-- 1399=QOK'' +SYY8i ((K@k'' +SYY8i ((K@k qy  )#w> JJc#}112'We reduce_max(values)`); * `0` (if `values` is empty); * `reduce_max(values) + 1` otherwise. Raises: `InvalidArgumentError` if negative values are provided as an input. Examples: **Bin-counting every item in individual batches** This example takes an input (which could be a Tensor, RaggedTensor, or SparseTensor) and returns a SparseTensor where the value of (i,j) is the number of times value j appears in batch i. >>> data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64) >>> tf.sparse.bincount(data, axis=-1) SparseTensor(indices=tf.Tensor( [[ 0 10] [ 0 20] [ 0 30] [ 1 11] [ 1 101] [ 1 10001]], shape=(6, 2), dtype=int64), values=tf.Tensor([1 2 1 2 1 1], shape=(6,), dtype=int64), dense_shape=tf.Tensor([ 2 10002], shape=(2,), dtype=int64)) This example shows a sparse tensor input. Missing zeros are not counted. >>> data = tf.sparse.SparseTensor( ... indices=[[0, 3], [0, 7], [0, 8], [0, 11], ... [1, 9], [1, 11], [1, 18], [1, 27]], ... values=[10, 20, 30, 20, 11, 101, 11, 10001], ... dense_shape=[2, 30]) >>> tf.sparse.bincount(data, axis=-1) SparseTensor(indices=tf.Tensor( [[ 0 10] [ 0 20] [ 0 30] [ 1 11] [ 1 101] [ 1 10001]], shape=(6, 2), dtype=int64), values=tf.Tensor([1 2 1 2 1 1], shape=(6,), dtype=int32), dense_shape=tf.Tensor([ 2 10002], shape=(2,), dtype=int64)) **Bin-counting with defined output shape** This example takes an input (which could be a Tensor, RaggedTensor, or SparseTensor) and returns a SparseTensor where the value of (i,j) is the number of times value j appears in batch i. However, all values of j above 'maxlength' are ignored. The dense_shape of the output sparse tensor is set to 'minlength'. Note that, while the input is identical to the example above, the value '10001' in batch item 2 is dropped, and the dense shape is [2, 500] instead of [2,10002] or [2, 102]. >>> minlength = maxlength = 500 >>> data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64) >>> tf.sparse.bincount( ... data, axis=-1, minlength=minlength, maxlength=maxlength) SparseTensor(indices=tf.Tensor( [[ 0 10] [ 0 20] [ 0 30] [ 1 11] [ 1 101]], shape=(5, 2), dtype=int64), values=tf.Tensor([1 2 1 2 1], shape=(5,), dtype=int64), dense_shape=tf.Tensor([ 2 500], shape=(2,), dtype=int64)) **Binary bin-counting** This example takes an input (which could be a Tensor, RaggedTensor, or SparseTensor) and returns a SparseTensor where (i,j) is 1 if the value j appears in batch i at least once and is 0 otherwise. Note that, even though some values (like 20 in batch 1 and 11 in batch 2) appear more than once, the 'values' tensor is all 1s. >>> data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64) >>> tf.sparse.bincount(data, binary_output=True, axis=-1) SparseTensor(indices=tf.Tensor( [[ 0 10] [ 0 20] [ 0 30] [ 1 11] [ 1 101] [ 1 10001]], shape=(6, 2), dtype=int64), values=tf.Tensor([1 1 1 1 1 1], shape=(6,), dtype=int64), dense_shape=tf.Tensor([ 2 10002], shape=(2,), dtype=int64)) **Weighted bin-counting** This example takes two inputs - a values tensor and a weights tensor. These tensors must be identically shaped, and have the same row splits or indices in the case of RaggedTensors or SparseTensors. When performing a weighted count, the op will output a SparseTensor where the value of (i, j) is the sum of the values in the weight tensor's batch i in the locations where the values tensor has the value j. In this case, the output dtype is the same as the dtype of the weights tensor. >>> data = np.array([[10, 20, 30, 20], [11, 101, 11, 10001]], dtype=np.int64) >>> weights = [[2, 0.25, 15, 0.5], [2, 17, 3, 0.9]] >>> tf.sparse.bincount(data, weights=weights, axis=-1) SparseTensor(indices=tf.Tensor( [[ 0 10] [ 0 20] [ 0 30] [ 1 11] [ 1 101] [ 1 10001]], shape=(6, 2), dtype=int64), values=tf.Tensor([2. 0.75 15. 5. 17. 0.9], shape=(6,), dtype=float32), dense_shape=tf.Tensor([ 2 10002], shape=(2,), dtype=int64)) countrIrxNrrrrrrrL)rrr)rrrr)rrBr rr"r "convert_to_tensor_v2_with_dispatchrCompositeTensorrrrIr rrsparse_count_sparse_outputrHrVrrdense_count_sparse_output) rIrrPrrrr4minlength_valuemaxlength_valuec_indc_valc_shapes r&rr sn ~~dGfg%678= fm88 9 CC x!f !1!A!A B#FF )%} = >> | d 7 =dVD66 77$-#8ibO#,#8ibO qy FM66 7  +FG<'  %%gt4'""6B40&-445'8g+FF .. --    ##%'eUG33FGDg+EE ##% 'eUG  % %eUG >2g3 .nnG . 3 .s  E<<Fcg}|d}|ddD]x}|jtj|j|jd|jtj|j|jdz|S)zCheck that all of `sparse_tensors` have same `indices` and `dense_shape`. Args: sparse_tensors: A list of sparse tensors. Returns: An op to be used as a control dependency. rrQNzMismatched shapes!rzMismatched indices!)rrrWrVrH)rrfirstts r&rr{ s &  % !" Fa MM   q}}6J LM MM MM199.C EF F -r(c"tj|d}g}|D]Z}t|tjr-|j ||j |j J|j |\tj||dS)aReplace `SparseTensor`s with their values in `value` Each `SparseTensor` in `value` is replaced by its `values` tensor, and collects all `SparseTensor`s in `sparse_list`. Args: value: A structure of `Tensor`s and `SparseTensor`s sparse_list: A list. Output parameter that collects all `SparseTensor`s in `value`. Returns: `value` with each SparseTensor replaced by its `.value` attribute. F)expand_composites)rflattenr rr"rrIpack_sequence_as)r=r flat_valsnew_valsvs r&rr syll5E:) ( a!]//0ooahhooa    uh% HHr(ct|}tj|j|j|j |||S)aAdd a `SparseTensor` to a `SparseTensorsMap` and return its handle. Args: sp_input: The input `SparseTensor`. container: The container for the underlying `SparseTensorsMap` (optional). shared_name: The shared name for the underlying `SparseTensorsMap` (optional, defaults to the name of the newly created op). name: A name prefix for the returned tensors (optional). Returns: A string 1-vector (1D `Tensor`), with the single element representing the a unique handle to a `SparseTensor` stored by the `SparseTensorMap` underlying this op. Raises: TypeError: If `sp_input` is not a `SparseTensor`.  container shared_namer4)r'radd_sparse_to_tensors_maprHrIrVr%rrr4s r&_add_sparse_to_tensors_mapr sC*'x 0(  1 1oo   r(ct|}tj|j|j|j |||S)a Add a minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles. The `SparseTensor` must have rank `R` greater than 1, and the first dimension is treated as the minibatch dimension. Elements of the `SparseTensor` must be sorted in increasing order of this first dimension. The serialized `SparseTensor` objects going into each row of the output `Tensor` will have rank `R-1`. The minibatch size `N` is extracted from `sparse_shape[0]`. Args: sp_input: The input rank `R` `SparseTensor`. container: The container for the underlying `SparseTensorsMap` (optional). shared_name: The shared name for the underlying `SparseTensorsMap` (optional, defaults to the name of the newly created op). name: A name prefix for the returned tensors (optional). Returns: A string matrix (2-D `Tensor`) with `N` rows and `1` column. Each row represents a unique handle to a `SparseTensor` stored by the `SparseTensorMap` underlying this op. Raises: TypeError: If `sp_input` is not a `SparseTensor`. r)r'radd_many_sparse_to_tensors_maprHrIrVrs r&_add_many_sparse_to_tensors_mapr sC:'x 0(  6 6oo   r(ct|tjs td|jdvrtd|jztj |5|j dxs |j}tj||j d|j d||\}}}dddjd|gj|gtj||S#1swYExYw) aRead `SparseTensors` from a `SparseTensorsMap` and concatenate them. The input `sparse_handles` must be a string matrix of shape `[N, 1]` where `N` is the minibatch size and the rows correspond to packed outputs of `add_sparse_to_tensors_map`. The ranks of the original `SparseTensor` objects must all match. When the final `SparseTensor` is created, it has rank one higher than the ranks of the incoming `SparseTensor` objects (they have been concatenated along a new row dimension). The output `SparseTensor` object's shape values for all dimensions but the first are the max across the input `SparseTensor` objects' shape values for the corresponding dimensions. Its first shape value is `N`, the minibatch size. The input `SparseTensor` objects' indices are assumed ordered in standard lexicographic order. If this is not the case, after this step run `sparse.reorder` to restore index ordering. For example, if the serialized input is a `[2, 3]` matrix representing two original `SparseTensor` objects: index = [ 0] [10] [20] values = [1, 2, 3] shape = [50] and index = [ 2] [10] values = [4, 5] shape = [30] then the final deserialized `SparseTensor` will be: index = [0 0] [0 10] [0 20] [1 2] [1 10] values = [1, 2, 3, 4, 5] shape = [2 50] Args: sparse_map_op: The `Operation` that created the original handles. Usually this is, e.g., `add_sparse_to_tensors_map(...).op`. sparse_handles: 2-D `Tensor` of type `string` of shape `[N, 1]`. The serialized and packed `SparseTensor` objects. rank: (optional) Python int, the rank of the `SparseTensor` objects. name: A name prefix for the returned tensors (optional) Returns: A `SparseTensor` representing the deserialized `SparseTensor`s, concatenated along the `SparseTensor`s' first dimension. All of the serialized `SparseTensor`s must have had the same rank and type. zsparse_map_op be an Operation)AddSparseToTensorsMapAddManySparseToTensorsMapzasparse_map_op must be one of AddSparseToTensorsMap or AddSparseToTensorsMap. Instead, found `%s`.rTr)r5rrr4N) r r Operationr$r? colocate_withget_attrr4r!take_many_sparse_from_tensors_maprrr") sparse_map_opsparse_handlesr\r4rr rrs r&"_take_many_sparse_from_tensors_mapr s | M3== 1 3 44 ==  68E8J8J K LL '((7M=;M;MK88 ((-#,,[9#  0NM<D$<($  # #NM< PPs !ADD ceZdZdZdZdZy)_UnaryMapValueDispatcherzHOpDispatcher for unary ops that maps base function across sparse values.c||_t|}tj|d}|d|_|j j dzdj|j|z|_y)Nrz zv If `{x}` is a `SparseTensor`, returns `SparseTensor({x}.indices, tf.{func}({x}.values, ...), {x}.dense_shape)`)rDfunc)_original_funcrrgetfullargspec_x__doc__rstripr;)r original_func func_name arg_namess r&__init__z!_UnaryMapValueDispatcher.__init__Jsp'D-mrJrcfloat32rndeprecated_endpointsdeprecated_argsrorvreplacerrr _sparse_crossr_sparse_cross_hashedrrrrradd_dispatch_supportrrrrr deprecatedrrrrr(r'r&r+r-r7r1rHrPr`rrergrlrnrqrtrwrrrrrdispatch_for_apirrXr"rrrrrrr OpDispatcherrabsnegativesignsquaresqrterftanh bessel_i0e bessel_i1e _UNARY_OPSunary_opregisterrr(r&rs "83.+5<943+1.+2/.0*23).+'-9J6&5*, > >>  fD!fDR <^^--D 01!!!/2 6 F',!(, mGF32mG` ?r"2#2j)0088;M   |\*+!!!,/ 7C9(C0,9(x 3H3Hl  !+"+\+ /8*/'($( $ 0HfL2 !13C DE!!!"2324F2j !13C DE!!!"23 e64Fe6R ~~./!!!.1 5{D"1"3 ED20EP >b!!"A&"A&H >~~>?!!!.1-42@-4`  !" MO #$%) 4O# 4n 2&EI['[| "$789!!!"56 9;H :5959L9H7:L9^ )+EFG!!!"<= 9;H#'&*,0'+ .JH>H.Jb 2&EIK'K\ "$789!!!"56 9;H :5959;9H7:;9| )+EFG!!!"<= 9;H#'&*,0'+ .JH>H.Jb "35M!NO!!!":;)-,0 $3<P3l 46KLN!!!"78;H9N;H| ~~./EF59 %]PG0]PF %* 6@r ?AB!!!/2*N3C*NZ 24HIK!!!"67cP8KcPL  ":;="!!":;<@<=<@~ $&89: !!!"45$(6==76;7$ R( +1==t)2 )+BCD !!!"9:)- <;E<6 %"- 06 D.D?QD  $&?@B !!!";<BQ=B BQJ '-."!!">?*/).$( j@.jZ !13C DE!!!"23:<4F:B'>BB<001<< J'-,,J'2J'Z   """' M=M=`!H*I4*.+/$(B/304)-%T-1,0SQl x44 > LL  MM OO MM LL MM  8H8$--h78r(