AVhX.dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#edZ$dde#e!ejJfde#e!e$fde#e!ejJfde&de&de#e!ejJff dZ'edejPe'Z)de#e!ejJfde#e!e$fde#e!ejJfde&de&de#e!ejJff dZ*edZ+dde#e!ejJfde#e!e+fde#e!ejJfde&de&de#e!ejJff dZ,edejPe,Z-de#e!ejJfde#e!e+fde#e!ejJfde&de&de#e!ejJff dZ.ej^dgd Z0ed!Z1dd"e#e!ejdfd#e1fd$Z3ed%ejPe3Z4d"e#e!ejdfd#e1fd&Z5ej^d'gd Z6ed(Z7ed)d*d+Z8dd"e#e!e8fd#e7fd,Z9ed-ejPe9Z:d"e#e!e8fd#e7fd.Z;ed/Z<ed0d*d+Z=e j|dfde#e!ejJfde#e!ed?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZHedPd=d@dAdBdCdDdEdFdLdMdNdO ZIddQe#e!ejJfdRe#e!eHfdSe#e!ejJfdTe#e!ejJfdUe#e!eHfdVe#e!ejJfdWe#e!eIffdXZJedYejPeJZKdQe#e!ejJfdRe#e!eHfdSe#e!ejJfdTe#e!ejJfdUe#e!eHfdVe#e!ejJfdWe#e!eIffdZZLej^d[d\d]gZMed^d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZNdd_e#e!eNfdQe#e!ejJfdTe#e!ejJfd`e#e!ejJffdaZOedbejPeOZPd_e#e!eNfdQe#e!ejJfdTe#e!ejJfd`e#e!ejJffdcZQej^ddgdeZRedfZSddge#e e!ejJfdhe#e e!eSfdie#e e!ejJfdjeTfdkZUedlejPeUZVdge#e e!ejJfdhe#e e!eSfdie#e e!ejJfdjeTfdmZWej^dngdeZXedodEd*ZYedpdEd*ZZddge#e e!ejJfdie#e e!ejJfdqe[dreTdseTd1eYdteZfduZ\edvejPe\Z]dge#e e!ejJfdie#e e!ejJfdqe[dreTdseTd1eYdteZfdwZ^ej^dxgdeZ_ddge#e e!ejJfdie#e e!ejJfdre#e!ejJfdye#e!ejfdze#e!ejJff d{Zaed|ejPeaZbdge#e e!ejJfdie#e e!ejJfdre#e!ejJfdye#e!ejfdze#e!ejJff d}Zcej^d~gdeZdddge#e e!ejJfdie#e e!ejJfde#e!ejdffdZeedejPeeZfdge#e e!ejJfdie#e e!ejJfde#e!ejdffdZgedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZhdde#e!ejJfde#e!ehfde#e!ejJfde#e!ehfde#e!ehff dZiedejPeiZjde#e!ejJfde#e!ehfde#e!ejJfde#e!ehfde#e!ehff dZkedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZldde#e!ejJfde#e!elfde#e!ejJfde#e!elfde#e!elff dZmedejPemZnde#e!ejJfde#e!elfde#e!ejJfde#e!elfde#e!elff dZoedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZpdde#e!ejJfde#e!epfde#e!ejJfde#e!epfde#e!epff dZqedejPeqZrde#e!ejJfde#e!epfde#e!ejJfde#e!epfde#e!epff dZsej^dgdZtedZuddge#e!ejJfdhe#e!eufde#e!ejJfde#e!euffdZvedejPevZwdge#e!ejJfdhe#e!eufde#e!ejJfde#e!euffdZxej^dddgZyedZzdde#e!ejJfde#e!ezffdZ{edejPe{Z|de#e!ejJfde#e!ezffdZ}edd=d@dAdBdCdDdEdFdLdMdNdO Z~dde#e!ejJfde#e!e~fde#e!ejJfde#e!ejfde[de#e!e~ff dZedejPeZde#e!ejJfde#e!e~fde#e!ejJfde#e!ejfde[de#e!e~ff dZej^dgdeZedd=d@dAdBdCdDdEdFdLdMdNdO Zdde#e!ejJfde#e!efde#e!ejJfde#e!ejfde[f dZedejPeZde#e!ejJfde#e!efde#e!ejJfde#e!ejfde[f dZedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZdde#e!ejJfde#e!efde#e!ejJfde#e!ejfde[de#e!eff dZedejPeZde#e!ejJfde#e!efde#e!ejJfde#e!ejfde[de#e!eff dZej^dgdeZedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZdde#e!ejJfde#e!efde#e!ejJfde#e!ejfde[f dZedejPeZde#e!ejJfde#e!efde#e!ejJfde#e!ejfde[f dZej^dddgZedZdde#e!ejJfde#e!efde#e!ejJffdZedejPeZde#e!ejJfde#e!efde#e!ejJffdZej^dddgZdde#e!ejJfde#e!ejJfde#e!ejJffdńZedƫejPeZde#e!ejJfde#e!ejJfde#e!ejJffdDŽZej^dgdeZedɎZddge#e!ejJfdhe#e!efde#e!ejJfde#e!ejJfde#e!ejJff d̈́ZedΫejPeZdge#e!ejJfdhe#e!efde#e!ejJfde#e!ejJfde#e!ejJff dτZedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZdd_e#e!efde#e!ejJfde#e!ejJfde#e!ejJfde#e!eff d҄ZedӫejPeZd_e#e!efde#e!ejJfde#e!ejJfde#e!ejJfde#e!eff dԄZedd@dAdBZdde#e!ejJfde#e!efde#e!ejJfde#e!effdքZed׫ejPeZde#e!ejJfde#e!efde#e!ejJfde#e!effd؄Zej^dddgZedd=d@dAdBdCdDdEdFdLdMdNdO ZddQe#e!ejJfdRe#e!efdSe#e!ejJfdTe#e!ejJfdUe#e!efdVe#e!ejJff dۄZedܫejPeZdQe#e!ejJfdRe#e!efdSe#e!ejJfdTe#e!ejJfdUe#e!efdVe#e!ejJff d݄Zej^dddgZedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZddQe#e!ejJfdRe#e!efdSe#e!ejJfdTe#e!ejJfdUe#e!efdVe#e!ejJff dZedejPeZdQe#e!ejJfdRe#e!efdSe#e!ejJfdTe#e!ejJfdUe#e!efdVe#e!ejJff dZej^dgdeZedZdde#e!ejJfdge#e!ejJfdhe#e!efde#e!ejJfdeTf dZedejPeZde#e!ejJfdge#e!ejJfdhe#e!efde#e!ejJfdeTf dZedd=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOZeddDdEZddQe#e!efdRe#e!efdSe#e!efde#e!efde#e!eff dZedejPeZdQe#e!efdRe#e!efdSe#e!efde#e!efde#e!eff dZedZeddDdEZddQe#e!efdRe#e!efdSe#e!ejJfde#e!efde[de[de#e!effdZedejPeZdQe#e!efdRe#e!efdSe#e!ejJfde#e!efde[de[de#e!effdZedZeddDdEZdde#e!efde#e!efde#e!efde#e!efde[de#e!eff dZedejPe«Zde#e!efde#e!efde#e!efde#e!efde[de#e!eff dZej^dgd ZedZƐdde#e!ejJfd#ede&de&fdZedejPeǫZde#e!ejJfd#ede&de&fdZy(zUPython wrappers around TensorFlow ops. This file is MACHINE GENERATED! Do not edit. N) pywrap_tfe)context)core)execute)dtypes)annotation_types)op_def_registry)ops)op_def_library)deprecated_endpoints)dispatch) tf_export)TypeVarListAny) Annotated) TV_AddManySparseToTensorsMap_T_atypes.BFloat16 _atypes.Bool_atypes.Complex128_atypes.Complex64_atypes.Float16_atypes.Float32_atypes.Float64_atypes.Float8e4m3b11fnuz_atypes.Float8e4m3fn_atypes.Float8e4m3fnuz_atypes.Float8e5m2_atypes.Float8e5m2fnuz _atypes.Half _atypes.Int16 _atypes.Int32 _atypes.Int4 _atypes.Int64 _atypes.Int8_atypes.QInt16_atypes.QInt32 _atypes.QInt8_atypes.QUInt16_atypes.QUInt8_atypes.Resource_atypes.String_atypes.UInt16_atypes.UInt32 _atypes.UInt4_atypes.UInt64 _atypes.UInt8_atypes.Variantsparse_indices sparse_values sparse_shape container shared_namereturnc Htjxstj}|j}|jr! t j |d||||d|d| }|S|d}tj|d}|d}tj|d}tj d||||||\} } } } | dd}tj"rYd| j%dd| j'dd| j'df} | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rY@wxYw) apAdd an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles. A `SparseTensor` of rank `R` is represented by three tensors: `sparse_indices`, `sparse_values`, and `sparse_shape`, where ```sparse_indices.shape[1] == sparse_shape.shape[0] == R``` An `N`-minibatch of `SparseTensor` objects is represented as a `SparseTensor` having a first `sparse_indices` column taking values between `[0, N)`, where the minibatch size `N == sparse_shape[0]`. The input `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 stored `SparseTensor` objects pointed to by each row of the output `sparse_handles` will have rank `R-1`. The `SparseTensor` values can then be read out as part of a minibatch by passing the given keys as vector elements to `TakeManySparseFromTensorsMap`. To ensure the correct `SparseTensorsMap` is accessed, ensure that the same `container` and `shared_name` are passed to that Op. If no `shared_name` is provided here, instead use the *name* of the Operation created by calling `AddManySparseToTensorsMap` as the `shared_name` passed to `TakeManySparseFromTensorsMap`. Ensure the Operations are colocated. Args: sparse_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the minibatch `SparseTensor`. `sparse_indices[:, 0]` must be ordered values in `[0, N)`. sparse_values: A `Tensor`. 1-D. The `values` of the minibatch `SparseTensor`. sparse_shape: A `Tensor` of type `int64`. 1-D. The `shape` of the minibatch `SparseTensor`. The minibatch size `N == sparse_shape[0]`. container: An optional `string`. Defaults to `""`. The container name for the `SparseTensorsMap` created by this op. shared_name: An optional `string`. Defaults to `""`. The shared name for the `SparseTensorsMap` created by this op. If blank, the new Operation's unique name is used. name: A name for the operation (optional). Returns: A `Tensor` of type `int64`. AddManySparseToTensorsMapr6r7Nr6r7namectxr3r4r5r6r7r<T)_contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException-add_many_sparse_to_tensors_map_eager_fallback_SymbolicException_executemake_str_op_def_library_apply_op_helpermust_record_gradient_get_attr_typeget_attrinputsrecord_gradientr3r4r5r6r7r<_ctxtld_resulte__op_outputs_attrs _inputs_flats T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_sparse_ops.pyadd_many_sparse_to_tensors_mapr`sZ    0h..0$ #\\  11 )4|[)]gnI ;7)K!!+}=+'88#N3@2>/81<4 I!QX QK' ""$3%%c*Kll;'ll=)+F::L #\67D (' .A  & &- ##At,,  # #    : -!$88  # #   0D--E4EE43E48F F! F!z!raw_ops.AddManySparseToTensorsMapc|d}tj|d}|d}tj|d}tj|g|g\}\}tj|t j }tj|t j }|||g}d|d|d|f} tjdd|| ||} tjrtjd|| | | \} | S) Nr>r6r7r@sAddManySparseToTensorsMaprSattrsr=r<r: rLrMargs_to_matching_eagerrGconvert_to_tensor_dtypesint64rrPrT r3r4r5r6r7r<r=_attr_Tr^r]rXs r_rJrJvsI ;7)K!!+}=+&==}osTVW' M)).'--H.'' gmmD, ->, +y- M&   91$0C"& ('""$ #\67D (' .) TV_AddSparseToTensorsMap_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2c Htjxstj}|j}|jr! t j |d||||d|d| }|S|d}tj|d}|d}tj|d}tj d||||||\} } } } | dd}tj"rYd| j%dd| j'dd| j'df} | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rY@wxYw) a+Add a `SparseTensor` to a `SparseTensorsMap` return its handle. A `SparseTensor` is represented by three tensors: `sparse_indices`, `sparse_values`, and `sparse_shape`. This operator takes the given `SparseTensor` and adds it to a container object (a `SparseTensorsMap`). A unique key within this container is generated in the form of an `int64`, and this is the value that is returned. The `SparseTensor` can then be read out as part of a minibatch by passing the key as a vector element to `TakeManySparseFromTensorsMap`. To ensure the correct `SparseTensorsMap` is accessed, ensure that the same `container` and `shared_name` are passed to that Op. If no `shared_name` is provided here, instead use the *name* of the Operation created by calling `AddSparseToTensorsMap` as the `shared_name` passed to `TakeManySparseFromTensorsMap`. Ensure the Operations are colocated. Args: sparse_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the `SparseTensor`. sparse_values: A `Tensor`. 1-D. The `values` of the `SparseTensor`. sparse_shape: A `Tensor` of type `int64`. 1-D. The `shape` of the `SparseTensor`. container: An optional `string`. Defaults to `""`. The container name for the `SparseTensorsMap` created by this op. shared_name: An optional `string`. Defaults to `""`. The shared name for the `SparseTensorsMap` created by this op. If blank, the new Operation's unique name is used. name: A name for the operation (optional). Returns: A `Tensor` of type `int64`. AddSparseToTensorsMapr6r7Nr;r>r?r@)rArrBrCrrDrErFrGrHrI(add_sparse_to_tensors_map_eager_fallbackrKrLrMrNrOrPrQrRrSrTrUs r_add_sparse_to_tensors_maprrsD    0h..0$ #\\ 11 %t^]k9m[JgnI ;7)K!!+}=+'88/<.:+4+&* ,!QX QK' ""$3%%c*Kll;'ll=)+F::L vw@ (' .A  & &- ##At,,  # #    5 -!$88  # #   razraw_ops.AddSparseToTensorsMapc|d}tj|d}|d}tj|d}tj|g|g\}\}tj|t j }tj|t j }|||g}d|d|d|f} tjdd|| ||} tjrtjd|| | | \} | S) Nr>r6r7r@sAddSparseToTensorsMaprcrdrprfrks r_rqrqsI ;7)K!!+}=+&==}osTVW' M)).'--H.'' gmmD, ->, +y- M&   5q#)s ?' ""$ vw@ (' .rmDeserializeManySparse)r3r4r5) TV_DeserializeManySparse_dtyperrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2serialized_sparsedtypectjxstj}|j}|jr2 t j |d||d|}t j|}|Stj |d}t#j$d|||\}}}} | dd}tj&r7d|j)df} |j*} tj,d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||S#tj$rY wxYw)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 `SerializeSparse`. 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 `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: A `Tensor` of type `string`. 2-D, The `N` serialized `SparseTensor` objects. Must have 3 columns. dtype: A `tf.DType`. The `dtype` of the serialized `SparseTensor` objects. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (sparse_indices, sparse_values, sparse_shape). sparse_indices: A `Tensor` of type `int64`. sparse_values: A `Tensor` of type `dtype`. sparse_shape: A `Tensor` of type `int64`. rtrwNrwr<r=rvrwr<)rArrBrCrrD_DeserializeManySparseOutput_makerErFrGrHrI&deserialize_many_sparse_eager_fallbackrKrL make_typerNrOrPrQrSrT rvrwr<rVrWrXrYrZr[r\r]r^s r_deserialize_many_sparsersuv    0h..0$ #\\  11 %t-> g-227;g n   UG ,%'883D',49!QX QK' ""$s))'2 3F::L vw@ ( . .w 7' .+  & &- ##At,,  # #    3 5t??  # #   s00D ED::EEE&&E=<E=zraw_ops.DeserializeManySparsec@tj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd|||tj|}|S)NrwsDeserializeManySparserdrt) rLr~rGrhristringrrPrTr{r|)rvrwr<r=r^r]rXs r_r}r}Vs   UG ,%,,->O#$, U &   5q#)s ?' ""$ vw@ ( . .w 7' .rmDeserializeSparse) TV_DeserializeSparse_dtyperrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 TV_DeserializeSparse_Tserializedr,r2c"tjxstj}|j}|jr2 t j |d||d|}t j|}|Stj |d}t#j$d|||\}}}} | dd}tj&rHd|j)dd|j)df} |j*} tj,d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||S#tj$rYwxYw)aDeserialize `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: A `Tensor`. Must be one of the following types: `string`, `variant`. The serialized `SparseTensor` objects. The last dimension must have 3 columns. dtype: A `tf.DType`. The `dtype` of the serialized `SparseTensor` objects. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (sparse_indices, sparse_values, sparse_shape). sparse_indices: A `Tensor` of type `int64`. sparse_values: A `Tensor` of type `dtype`. sparse_shape: A `Tensor` of type `int64`. rrwNryrz Tserialized)rArrBrCrrD_DeserializeSparseOutputr|rErFrGrHrI!deserialize_sparse_eager_fallbackrKrLr~rNrOrPrQrSrTrs r_deserialize_sparserksv    0h..0$ #\\ 11 !4):GULg(..w7g n   UG ,%'88/@"&(!QX QK' ""$s))'2M  /1F::L \67< $ * *7 3' .-  & &- ##At,,  # #    . 5t??  # #   s00DE$0E  E$#E$(E77F Fzraw_ops.DeserializeSparsectj|d}tj|g|tjtj gtj\}\}|g}d|d|f}tj dd||||}tjrtjd|||tj|}|S)NrwrsDeserializeSparserrdr) rLr~rgrirvariantrrPrTrr|)rvrwr<r=_attr_Tserializedr^r]rXs r_rrs   UG ,%,4,K,KM^L_adgnguguw~xGxGgJLSLZLZ-[))'#$, UM+< =&   11\#)s ?' ""$ \67< $ * *7 3' .rm) TV_SerializeManySparse_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2TV_SerializeManySparse_out_typeout_typec tjxstj}|j}|jr t j |d||||d|}|S|tj}tj |d}t#j$d|||||\} } } } | dd}tj&rHd| j)dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY!wxYw)a,Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object. 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 `serialized_sparse` will have rank `R-1`. The minibatch size `N` is extracted from `sparse_shape[0]`. Args: sparse_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the minibatch `SparseTensor`. sparse_values: A `Tensor`. 1-D. The `values` of the minibatch `SparseTensor`. sparse_shape: A `Tensor` of type `int64`. 1-D. The `shape` of the minibatch `SparseTensor`. out_type: An optional `tf.DType` from: `tf.string, tf.variant`. Defaults to `tf.string`. The `dtype` to use for serialization; the supported types are `string` (default) and `variant`. name: A name for the operation (optional). Returns: A `Tensor` of type `out_type`. SerializeManySparserNrr<r=r3r4r5rr<r@)rArrBrCrrDrErFrGrHrI$serialize_many_sparse_eager_fallbackrKrirrLr~rNrOrPrQrSrTr3r4r5rr<rVrWrXrYrZr[r\r]r^s r_serialize_many_sparsers4    0h..0$ #\\ 11 #T>=j(,gn~~H   * 5('88n-:,88$( *!QX QK' ""$3%%c*J  ,.F::L |VW> (' .7  & &- ##At,,  # #    1 -  # #   0D E D;;EEE))F?Fzraw_ops.SerializeManySparsec|tj}tj|d}tj|g|g\}\}t j |tj}t j |tj}|||g}d|d|f}tjdd||||} tjrtjd||| | \} | S)Nrr@sSerializeManySparsercrdr rirrLr~rgrGrhrjrrPrT r3r4r5rr<r=rlr^r]rXs r_rrs ~~H   * 5(&==}osTVW' M)).'--H.'' gmmD, ->, *h /&   3Q|#)s ?' ""$ |VW> (' .rm) TV_SerializeSparse_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2TV_SerializeSparse_out_typec tjxstj}|j}|jr t j |d||||d|}|S|tj}tj |d}t#j$d|||||\} } } } | dd}tj&rHd| j)dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY!wxYw)arSerialize a `SparseTensor` into a `[3]` `Tensor` object. Args: sparse_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the `SparseTensor`. sparse_values: A `Tensor`. 1-D. The `values` of the `SparseTensor`. sparse_shape: A `Tensor` of type `int64`. 1-D. The `shape` of the `SparseTensor`. out_type: An optional `tf.DType` from: `tf.string, tf.variant`. Defaults to `tf.string`. The `dtype` to use for serialization; the supported types are `string` (default) and `variant`. name: A name for the operation (optional). Returns: A `Tensor` of type `out_type`. SerializeSparserNrrr@)rArrBrCrrDrErFrGrHrIserialize_sparse_eager_fallbackrKrirrLr~rNrOrPrQrSrTrs r_serialize_sparser1s"    0h..0$ #\\ 11 ~}j(,gn~~H   * 5('88.)6(4x $ &!QX QK' ""$3%%c*J  ,.F::L <: (' .7  & &- ##At,,  # #    , -  # #   rzraw_ops.SerializeSparsec|tj}tj|d}tj|g|g\}\}t j |tj}t j |tj}|||g}d|d|f}tjdd||||} tjrtjd||| | \} | S)Nrr@sSerializeSparsercrdrrrs r_rrjs ~~H   * 5(&==}osTVW' M)).'--H.'' gmmD, ->, *h /&   /<#)s ?' ""$ <: (' .rm SparseAdd) sum_indices sum_values sum_shapeTV_SparseAdd_Trrrrrr r!r"r$r%r&r'r(r)r*r-r.r0r1TV_SparseAdd_Treal a_indicesa_valuesa_shape b_indicesb_valuesb_shapethreshc tjxstj}|j} | jr6 t j |d|||||||| } t j| } | Stj d|||||||| \} } } }|dd} t#j$rHd| j'dd| j'df}| j(}t#j*d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||| S#tj$rYwxYw)aK Adds two `SparseTensor` objects to produce another `SparseTensor`. The input `SparseTensor` objects' indices are assumed ordered in standard lexicographic order. If this is not the case, before this step run `SparseReorder` to restore index ordering. By default, if two values sum to zero at some index, the output `SparseTensor` would still include that particular location in its index, storing a zero in the corresponding value slot. To override this, callers can specify `thresh`, indicating that if the sum has a magnitude strictly smaller than `thresh`, its corresponding value and index would then not be included. In particular, `thresh == 0` (default) means everything is kept and actual thresholding happens only for a positive value. In the following shapes, `nnz` is the count after taking `thresh` into account. Args: a_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the first `SparseTensor`, size `[nnz, ndims]` Matrix. a_values: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 1-D. The `values` of the first `SparseTensor`, size `[nnz]` Vector. a_shape: A `Tensor` of type `int64`. 1-D. The `shape` of the first `SparseTensor`, size `[ndims]` Vector. b_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the second `SparseTensor`, size `[nnz, ndims]` Matrix. b_values: A `Tensor`. Must have the same type as `a_values`. 1-D. The `values` of the second `SparseTensor`, size `[nnz]` Vector. b_shape: A `Tensor` of type `int64`. 1-D. The `shape` of the second `SparseTensor`, size `[ndims]` Vector. thresh: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. 0-D. The magnitude threshold that determines if an output value/index pair takes space. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (sum_indices, sum_values, sum_shape). sum_indices: A `Tensor` of type `int64`. sum_values: A `Tensor`. Has the same type as `a_values`. sum_shape: A `Tensor` of type `int64`. rNr<r=)rrrrrrrr<r@Treal)rArrBrCrrD_SparseAddOutputr|rErFrGrHrIsparse_add_eager_fallbackrKrNrOrLrPrQrSrT)rrrrrrrr<rVrWrXrYrZr[r\r]r^s r_ sparse_addrsT    0h..0$ #\\  11 k4Hgy'6#g!&&w/g n(88y8W(8W"/!QX QK' ""$3%%c*G  )+F::L \674  " "7 +' ./  & &- ##At,,  # #    & Xw 8Wf  # #   s04DE#D>>EEE//FFzraw_ops.SparseAddc tj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\} } | \}}tj|g|tjtjtj tj tjtjtjtjtj"tj&tj(tj*g \} \}t-j.|tj}t-j.|tj}t-j.|tj}t-j.|tj}|||||||g} d| d| f} tj0dd| | ||}tj2rtj4d| | |t6j9|}|S)Nr@rs SparseAddrrdr)rLrgrifloat32float64int32uint8int16int8 complex64rjqint8quint8qint32bfloat16qint16quint16uint16 complex128halfuint32uint64rGrhrrPrTrr|)rrrrrrrr<r=rl _inputs_T _attr_Trealr^r]rXs r_rrsn66(7KSSZSbSbdkdsdsu|vCvCELERERT[TaTacjcocoqxqBqBDKDQDQSZS`S`bibpbpryr@r@BIBRBRT[TbTbdkdsdsu|uCuCELEWEWY`YeYegnguguw~wEwESHI'9"8X#::F8S7??\c\k\kmtmzmz}D}J}JLSLYLY[b[g[gipivivxxHxHJQJXJXZaZfZfhohvhvxxFxFKIJ+y$$Y >)  " "7GMM :'$$Y >)  " "7GMM :'Xw 8WfU, '; /&   \1\#)s ?' ""$ \674  " "7 +' .rm SparseAddGrad a_val_grad b_val_gradTV_SparseAddGrad_Tbackprop_val_gradrc tjxstj}|j}|jr3 t j |d|||||}t j|}|Stj d|||||\} } } } | dd}t#j$r7d| j'df} | j(} t#j*d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rYwxYw)aThe gradient operator for the SparseAdd op. The SparseAdd op calculates A + B, where A, B, and the sum are all represented as `SparseTensor` objects. This op takes in the upstream gradient w.r.t. non-empty values of the sum, and outputs the gradients w.r.t. the non-empty values of A and B. Args: backprop_val_grad: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 1-D with shape `[nnz(sum)]`. The gradient with respect to the non-empty values of the sum. a_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the `SparseTensor` A, size `[nnz(A), ndims]`. b_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the `SparseTensor` B, size `[nnz(B), ndims]`. sum_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the sum `SparseTensor`, size `[nnz(sum), ndims]`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (a_val_grad, b_val_grad). a_val_grad: A `Tensor`. Has the same type as `backprop_val_grad`. b_val_grad: A `Tensor`. Has the same type as `backprop_val_grad`. rNr)rrrrr<r@)rArrBrCrrD_SparseAddGradOutputr|rErFrGrHrIsparse_add_grad_eager_fallbackrKrNrOrLrPrQrSrT)rrrrr<rVrWrXrYrZr[r\r]r^s r_sparse_add_gradrsn6    0h..0$ #\\  11 ot%6 9g%**73g n(88+<#, %0t=!QX QK' ""$3%%c* +F::L vw8 & &w /' .-  & &- ##At,,  # #    + Y ;T  # #   01C99E D''E?EEE+*E+zraw_ops.SparseAddGradctj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}t-j.|tj}t-j.|tj}t-j.|tj}||||g}d|f}tj0dd||||} tj2rtj4d||| t6j9| } | S)Nr@s SparseAddGradrdr)rLrgrirrrrrrrrjrrrrrrrrrrrrGrhrrPrTrr|) rrrrr<r=rlr^r]rXs r_rr*sR"*"A"ACTBUWZ]d]l]lnun}n}@G@M@MOVO\O\^e^k^kmtmymy{B{L{LNUN[N[]d]j]jlslzlz|C|J|JLSL\L\^e^l^lnun}n}FMMOVOaOacjcocoqxqqAHAOAO]R#S'  $$Y >)$$Y >)&&{GMMB+#Y ;G, >&   -q#)s ?' ""$ vw8 & &w /' .rm SparseConcat)output_indices output_values output_shape) TV_SparseConcat_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2indicesvaluesshapes concat_dimc tjxstj}|j}|jr4 t j |d||||d|}t j|}|St|t t"fst%d|zt'|} t|t t"fst%d|zt'|| k7rt)dt'|| fzt|t t"fst%d|zt'|| k7rt)d t'|| fzt+j,|d}t/j0d||||| \} } } } | dd}t+j2rYd| j5dd | j5d d | j7d f} | j8}t+j:d|| |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rYwxYw) aConcatenates a list of `SparseTensor` along the specified dimension. Concatenation is with respect to the dense versions of these sparse tensors. It is assumed that each input is a `SparseTensor` whose elements are ordered along increasing dimension number. All inputs' shapes must match, except for the concat dimension. The `indices`, `values`, and `shapes` lists must have the same length. 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. 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 `concat_dim = 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 ] Args: indices: A list of at least 2 `Tensor` objects with type `int64`. 2-D. Indices of each input `SparseTensor`. values: A list with the same length as `indices` of `Tensor` objects with the same type. 1-D. Non-empty values of each `SparseTensor`. shapes: A list with the same length as `indices` of `Tensor` objects with type `int64`. 1-D. Shapes of each `SparseTensor`. concat_dim: An `int`. Dimension to concatenate along. Must be in range [-rank, rank), where rank is the number of dimensions in each input `SparseTensor`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values, output_shape). output_indices: A `Tensor` of type `int64`. output_values: A `Tensor`. Has the same type as `values`. output_shape: A `Tensor` of type `int64`. rrN)rr<r=CExpected list for 'indices' argument to 'sparse_concat' Op, not %r.BExpected list for 'values' argument to 'sparse_concat' Op, not %r.gList argument 'values' to 'sparse_concat' Op with length %d must match length %d of argument 'indices'.BExpected list for 'shapes' argument to 'sparse_concat' Op, not %r.gList argument 'shapes' to 'sparse_concat' Op with length %d must match length %d of argument 'indices'.)rrrrr<Nr@)rArrBrCrrD_SparseConcatOutputr|rErFrGrHrIsparse_concat_eager_fallbackrK isinstancelisttuple TypeErrorlen ValueErrorrLmake_intrNrOrP _get_attr_intrQrSrT)rrrrr<rVrWrXrY_attr_NrZr[r\r]r^s r_ sparse_concatr@s@    0h..0$ #\\  11 ndGVV\g$))'2g n GdE] +  &(/ 0 11 L' FT5M *  &(. / 00 [G  6 Vg    FT5M *  &(. / 00 [G  6 Vg     \:*'88v#-D:!QX QK' ""$C--l;S$c3+=+=c+BDF::L  fg7  % %g .' .[  & &- ##At,,  # #    ) 66jtOO  # #   s02G77H> H%%H>=H>II*)I*zraw_ops.SparseConcatct|ttfstd|zt |}t|ttfstd|zt ||k7rt dt ||fzt|ttfstd|zt ||k7rt dt ||fzt j|d}t jt||g\}}tj|tj}tj|tj}t|t|zt|z}d|d|d|f} t jd d || || } t jrt jd || | t j#| } | S) Nrrrrrrrr@s SparseConcatrrdr)rrrrrrrLrrgrGconvert_n_to_tensorrirjrrPrTrr|) rrrrr<r=rrlr^r]rXs r_rrs GdE] +  &(/ 0 11 L' FT5M *  &(. / 00 [G  6 Vg    FT5M *  &(. / 00 [G  6 Vg     \:*33DL#rJ/'6  $ $Wgmm <'  # #FGMM :&gf-V <, *c7C A&   _a #)s ?' ""$  fg7  % %g .' .rm SparseCrossTV_SparseCross_out_typeTV_SparseCross_internal_type hashed_output num_bucketshash_key internal_typec tjxstj} | j} | jr= t j | d| ||||d|d|d|d|d|} t j| } | St|t t"fst%d |zt'|}t|t t"fst%d |zt'||k7rt)d t'||fzt+j,|d}t+j.|d}t+j.|d}t+j0|d}t+j0|d}t3j4d|||||||||| \}}}}|dd} t+j6rd |j9d d|j;dd|j9dd|j9dd|j=dd|j=dd|j?dd|j?df}|j@}t+jBd||| t j| } | S#tj$r } tj| | Yd} ~ nd} ~ wtj$rYnwxYw t|||||||||| |  S#tj$rYbwxYw)a Generates sparse cross from a list of sparse and dense tensors. The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each representing features of one feature column. It outputs a 2D `SparseTensor` with the batchwise crosses of these features. 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" if hashed_output=true 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: indices: A list of `Tensor` objects with type `int64`. 2-D. Indices of each input `SparseTensor`. values: A list of `Tensor` objects with types from: `int64`, `string`. 1-D. values of each `SparseTensor`. shapes: A list with the same length as `indices` of `Tensor` objects with type `int64`. 1-D. Shapes of each `SparseTensor`. dense_inputs: A list of `Tensor` objects with types from: `int64`, `string`. 2-D. Columns represented by dense `Tensor`. hashed_output: A `bool`. If true, returns the hash of the cross instead of the string. This will allow us avoiding string manipulations. num_buckets: An `int` that is `>= 0`. It is used if hashed_output is true. output = hashed_value%num_buckets if num_buckets > 0 else hashed_value. hash_key: An `int`. Specify the hash_key that will be used by the `FingerprintCat64` function to combine the crosses fingerprints. out_type: A `tf.DType` from: `tf.int64, tf.string`. internal_type: A `tf.DType` from: `tf.int64, tf.string`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values, output_shape). output_indices: A `Tensor` of type `int64`. output_values: A `Tensor` of type `out_type`. output_shape: A `Tensor` of type `int64`. rrrrrrN)rrrrrr<r=BExpected list for 'indices' argument to 'sparse_cross' Op, not %r.AExpected list for 'shapes' argument to 'sparse_cross' Op, not %r.fList argument 'shapes' to 'sparse_cross' Op with length %d must match length %d of argument 'indices'.) rrr dense_inputsrrrrrr<r sparse_types dense_types)"rArrBrCrrD_SparseCrossOutputr|rErFrGrHrIsparse_cross_eager_fallbackrKrrrrrrrL make_boolrr~rNrOrPr_get_attr_boolrRrQrSrT)rrrrrrrrrr<rVrWrXrYrrZr[r\r]r^s r_ sparse_crossrsH    0h..0$ #\\  11 mT7FFL {Hj(O g #((1g n GdE] +  %'. / 00 L' FT5M *  %'- . // [G  6 Vg   $$]OD-!!+}=+   x 4(   * 5($$]OD-'88wvf$0 #. (  "!QX QK' ""$3$$S)?  1= .  +^ll>*Mll=):  ,o  13F::L |VW6  $ $W -' .g  & &- ##At,,  # #    ( 66<}!Hx%Dd<<  # #   s0;I''J.:JJ.-J.2KKKzraw_ops.SparseCrossc t|ttfstd|zt |} t|ttfstd|zt || k7rt dt || fzt j|d}t j|d}t j|d}t j|d}t j|d}t j|| \} }t j|| \} }tj|tj}tj|tj}t|t|zt|zt|z}d | d|d|d|d | d | d|d|f}t jd d ||| | }t j rt j"d|||t$j'|}|S)Nrrrrrrrrrrrs SparseCrossrrdr)rrrrrrrLrrr~convert_to_mixed_eager_tensorsrGrrirjrrPrTrr|)rrrrrrrrrr<r=r_attr_sparse_types_attr_dense_typesr^r]rXs r_rrps GdE] +  %'. / 00 L' FT5M *  %'- . // [G  6 Vg   $$]OD-!!+}=+   x 4(   * 5($$]OD-'FFvsSf$,$K$KLZ]$^!\  $ $Wgmm <'  # #FGMM :&gf-V  0 else hashed_value. strong_hash: A `Tensor` of type `bool`. boolean, if true, siphash with salt will be used instead of farmhash. salt: A `Tensor` of type `int64`. Specify the salt that will be used by the siphash function. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values, output_shape). output_indices: A `Tensor` of type `int64`. output_values: A `Tensor` of type `int64`. output_shape: A `Tensor` of type `int64`. r NrIExpected list for 'indices' argument to 'sparse_cross_hashed' Op, not %r.HExpected list for 'shapes' argument to 'sparse_cross_hashed' Op, not %r.mList argument 'shapes' to 'sparse_cross_hashed' Op with length %d must match length %d of argument 'indices'.)rrrrrrrr<rrr)rArrBrCrrD_SparseCrossHashedOutputr|rErFrGrHrI"sparse_cross_hashed_eager_fallbackrKrrrrrrrNrOrLrPrrRrSrT)rrrrrrrr<rVrWrXrYrrZr[r\r]r^s r_sparse_cross_hashedrs0B    0h..0$ #\\  11 !4&&k;6g)..w7g n GdE] +  ,.5 6 77 L' FT5M *  ,.4 5 66 [G  6 Vg   (88WVF*6)4+"&T 3!QX QK' ""$3$$S)>ll>*Mll=)+F::L \67< $ * *7 3' .O  & &- ##At,,  # #    / 66<k Tt%%  # #   s04FG".G  G"!G"&G::HHzraw_ops.SparseCrossHashedc t|ttfstd|zt |} t|ttfstd|zt || k7rt dt || fzt j||\} }t j||\} }tj|tj}tj|tj}tj|tj}tj|tj}tj|tj}t|t|zt|zt|z|||gz} d| d| d| f} t jdd| | || }t jrt j d | | |t"j%|}|S) NrrrrrrsSparseCrossHashedrrdr )rrrrrrrLr rGrrirjrhboolrrPrTrr|)rrrrrrrr<r=rr r r^r]rXs r_rrs GdE] +  ,.5 6 77 L' FT5M *  ,.4 5 66 [G  6 Vg    (FFvsSf$,$K$KLZ]$^!\  $ $Wgmm <'  # #FGMM :&&&{GMMB+&&{GLLA+  gmm 4$gf-V ll>*Mll=)+F::L vw8 & &w /' .I  & &- ##At,,  # #    + 66<4TKK  # #   s02FG*GGG"G44H  H zraw_ops.SparseCrossV2cdt|ttfstd|zt |}t|ttfstd|zt ||k7rt dt ||fzt j||\}}t j||\} }tj|tj}tj|tj}tj|tj}t|t|zt|zt|z|gz} d|d|d| f} t jdd| | || } t jrt j d | | | t"j%| } | S) Nrrrrrrs SparseCrossV2rrdr)rrrrrrrLr rGrrirjrhrrrPrTrr|) rrrrrr<r=rr r r^r]rXs r_r r s GdE] +  (*1 2 33 L' FT5M *  (*0 1 22 [G  6 Vg    (FFvsSf$,$K$KLZ]$^!\  $ $Wgmm <'  # #FGMM :& sGNN3#gf-V  (' .)  & &- ##At,,  # #    2 i5tGG  # #   0CD&DDDD//EEzraw_ops.SparseDenseCwiseAddctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}}|\}}t-j.|tj}t-j.|tj}||||g}d|f} tj0dd|| ||} tj2rtj4d|| | | \} | S)Nr@sSparseDenseCwiseAddrcrdr)rLrgrirrrrrrrrjrrrrrrrrrrrrGrhrrPrT r$r%r&r'r<r=rlrr^r]rXs r_r+r+566 57I3QXQ`Q`bibqbqsztAtACJCPCPRYR_R_ahamamovo@o@BIBOBOQXQ^Q^`g`n`npwp~p~@G@P@PRYR`R`bibqbqszsAsACJCUCUW^WcWcelesesu|uCuCQFG'9 9e%%j'--@*  # #Hgmm <(i59, >&   3Q|#)s ?' ""$ |VW> (' .rmTV_SparseDenseCwiseDiv_Tc tjxstj}|j}|jr t j |d|||||}|Stjd|||||\} } } } | dd}tj r7d| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)aComponent-wise divides a SparseTensor by a dense Tensor. *Limitation*: this Op only broadcasts the dense side to the sparse side, but not the other direction. Args: sp_indices: A `Tensor` of type `int64`. 2-D. `N x R` matrix with the indices of non-empty values in a SparseTensor, possibly not in canonical ordering. sp_values: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 1-D. `N` non-empty values corresponding to `sp_indices`. sp_shape: A `Tensor` of type `int64`. 1-D. Shape of the input SparseTensor. dense: A `Tensor`. Must have the same type as `sp_values`. `R`-D. The dense Tensor operand. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `sp_values`. SparseDenseCwiseDivNrr*r@)rArrBrCrrDrErFrGrHrI%sparse_dense_cwise_div_eager_fallbackrKrNrOrLrPrQrSrTr,s r_sparse_dense_cwise_divr7sS*    0h..0$ #\\ 11 #T:y( gn(88* (0DJ!QX QK' ""$3%%c* +F::L |VW> (' .)  & &- ##At,,  # #    2 i5tGG  # #   r.zraw_ops.SparseDenseCwiseDivctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}}|\}}t-j.|tj}t-j.|tj}||||g}d|f} tj0dd|| ||} tj2rtj4d|| | | \} | S)Nr@sSparseDenseCwiseDivrcrdr5r0r1s r_r6r6Jr2rmTV_SparseDenseCwiseMul_Tc tjxstj}|j}|jr t j |d|||||}|Stjd|||||\} } } } | dd}tj r7d| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)aComponent-wise multiplies a SparseTensor by a dense Tensor. The output locations corresponding to the implicitly zero elements in the sparse tensor will be zero (i.e., will not take up storage space), regardless of the contents of the dense tensor (even if it's +/-INF and that INF*0 == NaN). *Limitation*: this Op only broadcasts the dense side to the sparse side, but not the other direction. Args: sp_indices: A `Tensor` of type `int64`. 2-D. `N x R` matrix with the indices of non-empty values in a SparseTensor, possibly not in canonical ordering. sp_values: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 1-D. `N` non-empty values corresponding to `sp_indices`. sp_shape: A `Tensor` of type `int64`. 1-D. Shape of the input SparseTensor. dense: A `Tensor`. Must have the same type as `sp_values`. `R`-D. The dense Tensor operand. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `sp_values`. SparseDenseCwiseMulNrr*r@)rArrBrCrrDrErFrGrHrI%sparse_dense_cwise_mul_eager_fallbackrKrNrOrLrPrQrSrTr,s r_sparse_dense_cwise_mulr=\sS2    0h..0$ #\\ 11 #T:y( gn(88* (0DJ!QX QK' ""$3%%c* +F::L |VW> (' .)  & &- ##At,,  # #    2 i5tGG  # #   r.zraw_ops.SparseDenseCwiseMulctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}}|\}}t-j.|tj}t-j.|tj}||||g}d|f} tj0dd|| ||} tj2rtj4d|| | | \} | S)Nr@sSparseDenseCwiseMulrcrdr;r0r1s r_r<r<r2rmSparseFillEmptyRows)rrempty_row_indicatorreverse_index_map) TV_SparseFillEmptyRows_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 dense_shape default_valuec tjxstj}|j}|jr3 t j |d|||||}t j|}|Stj d|||||\} } } } | dd}t#j$r7d| j'df} | j(} t#j*d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rYwxYw)aJFills empty rows in the input 2-D `SparseTensor` with a default value. The input `SparseTensor` is represented via the tuple of inputs (`indices`, `values`, `dense_shape`). The output `SparseTensor` has the same `dense_shape` but with indices `output_indices` and values `output_values`. This op inserts a single entry for every row that doesn't have any values. The index is created as `[row, 0, ..., 0]` and the inserted value is `default_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 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 shaped `[dense_shape[0]]` such that empty_row_indicator[i] = True iff row i was an empty row. And a reverse index map vector shaped `[indices.shape[0]]` that is used during backpropagation, reverse_index_map[j] = out_j s.t. indices[j, :] == output_indices[out_j, :] Args: indices: A `Tensor` of type `int64`. 2-D. the indices of the sparse tensor. values: A `Tensor`. 1-D. the values of the sparse tensor. dense_shape: A `Tensor` of type `int64`. 1-D. the shape of the sparse tensor. default_value: A `Tensor`. Must have the same type as `values`. 0-D. default value to insert into location `[row, 0, ..., 0]` for rows missing from the input sparse tensor. output indices: 2-D. the indices of the filled sparse tensor. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values, empty_row_indicator, reverse_index_map). output_indices: A `Tensor` of type `int64`. output_values: A `Tensor`. Has the same type as `values`. empty_row_indicator: A `Tensor` of type `bool`. reverse_index_map: A `Tensor` of type `int64`. r?Nr)rrrCrDr<r@)rArrBrCrrD_SparseFillEmptyRowsOutputr|rErFrGrHrI%sparse_fill_empty_rows_eager_fallbackrKrNrOrLrPrQrSrT)rrrCrDr<rVrWrXrYrZr[r\r]r^s r_sparse_fill_empty_rowsrHsnx    0h..0$ #\\  11 #T7FKg+009g n(88wv+6-:G!QX QK' ""$3%%c* +F::L |VW> & , ,W 5' .+  & &- ##At,,  # #    2 6; DdLL  # #   rzraw_ops.SparseFillEmptyRowsctj||g|g\}}|\}}tj|tj }tj|tj }||||g}d|f} tj dd|| ||} tjrtjd|| | tj| } | S)Nr@sSparseFillEmptyRowsrdr?) rLrgrGrhrirjrrPrTrFr|) rrrCrDr<r=rlrr^r]rXs r_rGrG s66 7NPSUWX'9%6=  " "7GMM :'&&{GMMB+6; >, >&   3Q|#)s ?' ""$ |VW> & , ,W 5' .rmSparseFillEmptyRowsGradd_valuesd_default_value) TV_SparseFillEmptyRowsGrad_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2rA grad_valuesctjxstj}|j}|jr1 t j |d|||}t j|}|Stj d|||\}}}} | dd}t#j$r7d|j'df} |j(} t#j*d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||S#tj$rYwxYw)ajThe gradient of SparseFillEmptyRows. Takes vectors reverse_index_map, shaped `[N]`, and grad_values, shaped `[N_full]`, where `N_full >= N` and copies data into either `d_values` or `d_default_value`. Here `d_values` is shaped `[N]` and `d_default_value` is a scalar. d_values[j] = grad_values[reverse_index_map[j]] d_default_value = sum_{k : 0 .. N_full - 1} ( grad_values[k] * 1{k not in reverse_index_map}) Args: reverse_index_map: A `Tensor` of type `int64`. 1-D. The reverse index map from SparseFillEmptyRows. grad_values: A `Tensor`. 1-D. The gradients from backprop. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (d_values, d_default_value). d_values: A `Tensor`. Has the same type as `grad_values`. d_default_value: A `Tensor`. Has the same type as `grad_values`. rKNr)rArOr<r@)rArrBrCrrD_SparseFillEmptyRowsGradOutputr|rErFrGrHrI*sparse_fill_empty_rows_grad_eager_fallbackrKrNrOrLrPrQrSrT) rArOr<rVrWrXrYrZr[r\r]r^s r_sparse_fill_empty_rows_gradrS!s_0    0h..0$ #\\ 11 '/@+Og.44W=g n(88!5F/:G!QX QK' ""$3%%c* +F::L !<B * 0 0 9' .)  & &- ##At,,  # #    7 ??  # #   s0/C55D<D##D<;D<EE%$E%zraw_ops.SparseFillEmptyRowsGradcPtj|g|g\}\}tj|tj }||g}d|f}tj dd||||}tjrtjd|||tj|}|S)Nr@sSparseFillEmptyRowsGradrrdrK) rLrgrGrhrirjrrPrTrQr|)rArOr<r=rlr^r]rXs r_rRrRZs$;;[M3PRS'>K,,-> N#[1, >&   7$0C"& ('""$ !<B * 0 0 9' .rmTV_SparseReduceMax_T input_indices input_values input_shapereduction_axes keep_dimsc tjxstj}|j}|jr t j |d|||||d| }|S|d}tj|d}tj d||||||\} } } } | dd}tj"rHd| j%dd| j'df} | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYw)a Computes the max of elements across dimensions of a SparseTensor. 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. Reduces `sp_input` along the dimensions given in `reduction_axes`. Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in `reduction_axes`. If `keep_dims` 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: input_indices: A `Tensor` of type `int64`. 2-D. `N x R` matrix with the indices of non-empty values in a SparseTensor, possibly not in canonical ordering. input_values: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. 1-D. `N` non-empty values corresponding to `input_indices`. input_shape: A `Tensor` of type `int64`. 1-D. Shape of the input SparseTensor. reduction_axes: A `Tensor` of type `int32`. 1-D. Length-`K` vector containing the reduction axes. keep_dims: An optional `bool`. Defaults to `False`. If true, retain reduced dimensions with length 1. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input_values`. SparseReduceMaxrZNrZr<r=FrVrWrXrYrZr<r@)rArrBrCrrDrErFrGrHrI sparse_reduce_max_eager_fallbackrKrLrrNrOrPrrQrSrTrVrWrXrYrZr<rVrWrXrYrZr[r\r]r^s r_sparse_reduce_maxrakB    0h..0$ #\\ 11 }l^[)=gnI  K8)'88(4+*8I $ &!QX QK' ""$3--k:C  %'F::L <: (' .7  & &- ##At,,  # #    - {NDd44  # #   0DED//EE EE54E5zraw_ops.SparseReduceMaxcb|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjg \}\}t!j"|tj}t!j"|tj}t!j"|tj }||||g}d|d|f} tj$dd|| ||} tj&rtj(d|| | | \} | S)NFrZr@sSparseReduceMaxrcrdr\)rLrrgrirrrrrrrjrrrrrrGrhrrPrT rVrWrXrYrZr<r=rlr^r]rXs r_r_r_sI  K8)%<+44 A!QX QK' ""$3--k:C  %'F::L vw@ ( . .w 7' .9  & &- ##At,,  # #    4 {NDd44  # #   03D''E.:EE.-E.2FFFzraw_ops.SparseReduceMaxSparsec|d}tj|d}tj|g|tjtj tj tjtjtjtjtjtjtjtjtjg \}\}t!j"|tj}t!j"|tj}t!j"|tj }||||g}d|d|f} tj$dd|| ||} tj&rtj(d|| | t*j-| } | S)NFrZr@sSparseReduceMaxSparserrdrf)rLrrgrirrrrrrrjrrrrrrGrhrrPrTrir|res r_rjrjsI  K8)%< D%%D>=D>EE('E(zraw_ops.SparseReorderctj|g|g\}\}tj|tj }tj|tj }|||g}d|f}tj dd||||}tjrtjd|||tj|}|S)Nr@s SparseReorderrrdr|) rLrgrGrhrirjrrPrTrr|) rVrWrXr<r=rlr^r]rXs r_rr9 s%<&   -q#)s ?' ""$ vw8 & &w /' .rm SparseReshaper new_shapectjxstj}|j}|jr2 t j |d||||}t j|}|Stj d||||\}}} } | dd}t#j$r&d} | j&} t#j(d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||S#tj$rYwxYw)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 `input_indices` are recomputed based on the requested `new_shape`. If one component of `new_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 `new_shape` can be -1. The number of dense elements implied by `new_shape` must be the same as the number of dense elements originally implied by `input_shape`. Reshaping does not affect the order of values in the SparseTensor. If the input tensor has rank `R_in` and `N` non-empty values, and `new_shape` has length `R_out`, then `input_indices` has shape `[N, R_in]`, `input_shape` has length `R_in`, `output_indices` has shape `[N, R_out]`, and `output_shape` has length `R_out`. Args: input_indices: A `Tensor` of type `int64`. 2-D. `N x R_in` matrix with the indices of non-empty values in a SparseTensor. input_shape: A `Tensor` of type `int64`. 1-D. `R_in` vector with the input SparseTensor's dense shape. new_shape: A `Tensor` of type `int64`. 1-D. `R_out` vector with the requested new dense shape. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_shape). output_indices: A `Tensor` of type `int64`. output_shape: A `Tensor` of type `int64`. rNr)rVrXrr<)rArrBrCrrD_SparseReshapeOutputr|rErFrGrHrIsparse_reshape_eager_fallbackrKrNrOrLrPrSrT) rVrXrr<rVrWrXrYrZr[r\r]r^s r_sparse_reshaperL sSF    0h..0$ #\\ 11 ot]KLg$**73g n(88}+#,49!QX QK' ""$ F::L vw8 & &w /' .)  & &- ##At,,  # #    * idFF  # #   s00C&&D-9DD-,D-1EEEzraw_ops.SparseReshapectj|tj}tj|tj}tj|tj}|||g}d}t j dd||||}t j rt jd|||tj|}|S)Ns SparseReshaperrdr) rGrhrirjrLrrPrTrr|)rVrXrr<r=r^r]rXs r_rr s(( F-&&{GMMB+$$Y >)i8, &   -q#)s ?' ""$ vw8 & &w /' .rm SparseSlice) TV_SparseSlice_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2shapestartsizec tjxstj}|j}|jr4 t j |d||||||}t j|}|Stj d||||||\} } } } | dd}t#j$r7d| j'df} | j(}t#j*d|| |t j|}|S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t|||||||S#tj$rYwxYw)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: indices: A `Tensor` of type `int64`. 2-D tensor represents the indices of the sparse tensor. values: A `Tensor`. 1-D tensor represents the values of the sparse tensor. shape: A `Tensor` of type `int64`. 1-D. tensor represents the shape of the sparse tensor. start: A `Tensor` of type `int64`. 1-D. tensor represents the start of the slice. size: A `Tensor` of type `int64`. 1-D. tensor represents the size of the slice. output indices: A list of 1-D tensors represents the indices of the output sparse tensors. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values, output_shape). output_indices: A `Tensor` of type `int64`. output_values: A `Tensor`. Has the same type as `values`. output_shape: A `Tensor` of type `int64`. rNr)rrrrrr<r@)rArrBrCrrD_SparseSliceOutputr|rErFrGrHrIsparse_slice_eager_fallbackrKrNrOrLrPrQrSrT)rrrrrr<rVrWrXrYrZr[r\r]r^s r_ sparse_slicer soP    0h..0$ #\\ 11 mT7FE5$Hg"((1g n(88wvU"D:!QX QK' ""$3%%c* +F::L |VW6  $ $W -' .)  & &- ##At,,  # #    ( 65%DdDD  # #   s02C;;ED))EEEE.-E.zraw_ops.SparseSlicec.tj|g|g\}\}tj|tj }tj|tj }tj|tj }tj|tj }|||||g}d|f} tj dd|| ||} tjrtjd|| | tj| } | S)Nr@s SparseSlicerrdr) rLrgrGrhrirjrrPrTrr|) rrrrrr<r=rlr^r]rXs r_rr s66xbI'9F  " "7GMM :'   6%   6%  gmm 4$65%6, >&   ^Q|#)s ?' ""$ |VW6  $ $W -' .rmTV_SparseSliceGrad_T input_startc tjxstj}|j}|jr t j |d|||||}|Stjd|||||\} } } } | dd}tj r7d| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)aThe gradient operator for the SparseSlice op. This op takes in the upstream gradient w.r.t. non-empty values of the sliced `SparseTensor`, and outputs the gradients w.r.t. the non-empty values of input `SparseTensor`. Args: backprop_val_grad: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 1-D. The gradient with respect to the non-empty values of the sliced `SparseTensor`. input_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the input `SparseTensor`. input_start: A `Tensor` of type `int64`. 1-D. tensor represents the start of the slice. output_indices: A `Tensor` of type `int64`. 2-D. The `indices` of the sliced `SparseTensor`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `backprop_val_grad`. SparseSliceGradNr)rrVrrr<r@)rArrBrCrrDrErFrGrHrI sparse_slice_grad_eager_fallbackrKrNrOrLrPrQrSrT)rrVrrr<rVrWrXrYrZr[r\r]r^s r_sparse_slice_gradr sX,    0h..0$ #\\ 11 '8-^%gn(88->)6'2*8t E!QX QK' ""$3%%c* +F::L <: (' ./  & &- ##At,,  # #    - ]K  # #   r.zraw_ops.SparseSliceGradctj|g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}\}t-j.|tj}t-j.|tj}t-j.|tj}||||g}d|f}tj0dd||||} tj2rtj4d||| | \} | S)Nr@sSparseSliceGradrcrdrr0) rrVrrr<r=rlr^r]rXs r_rr; sI"*"A"ACTBUWZ]d]l]lnun}n}@G@M@MOVO\O\^e^k^kmtmymy{B{L{LNUN[N[]d]j]jlslzlz|C|J|JLSL\L\^e^l^lnun}n}FMMOVOaOacjcocoqxqqAHAOAO]R#S'  (( F-&&{GMMB+)).'--H.#]KP, >&   /<#)s ?' ""$ <: (' .rmTV_SparseSoftmax_Tctjxstj}|j}|jr t j |d||||}|Stjd||||\}}} } | dd}tj r7d| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rYwxYw)a0Applies 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 the following: (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. Args: sp_indices: A `Tensor` of type `int64`. 2-D. `NNZ x R` matrix with the indices of non-empty values in a SparseTensor, in canonical ordering. sp_values: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`. 1-D. `NNZ` non-empty values corresponding to `sp_indices`. sp_shape: A `Tensor` of type `int64`. 1-D. Shape of the input SparseTensor. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `sp_values`. SparseSoftmaxNr)r$r%r&r<r@)rArrBrCrrDrErFrGrHrIsparse_softmax_eager_fallbackrKrNrOrLrPrQrSrT) r$r%r&r<rVrWrXrYrZr[r\r]r^s r_sparse_softmaxrM sJ@    0h..0$ #\\ 11 otZHFg n(88J)"*7!QX QK' ""$3%%c* +F::L vw8 (' .)  & &- ##At,,  # #    * i$@@  # #   s0CD$C??DDD,,EEzraw_ops.SparseSoftmaxctj|g|tjtjtj g\}\}t j|tj}t j|tj}|||g}d|f}tjdd||||}tjrtjd||||\}|S)Nr@s SparseSoftmaxrcrdr) rLrgrirrrrGrhrjrrPrT) r$r%r&r<r=rlr^r]rXs r_rr s"999+sW\\[b[j[jlsl{l{L~'&   -q#)s ?' ""$ vw8 (' .rmSparseSparseMaximumTV_SparseSparseMaximum_Tc tjxstj}|j}|jr5 t j |d||||||| } t j| } | Stj d|||||||\} } } } | dd} t#j$r7d| j'df}| j(}t#j*d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||S#tj$rYwxYw)aReturns the element-wise max of two SparseTensors. Assumes the two SparseTensors have the same shape, i.e., no broadcasting. Args: a_indices: A `Tensor` of type `int64`. 2-D. `N x R` matrix with the indices of non-empty values in a SparseTensor, in the canonical lexicographic ordering. a_values: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. 1-D. `N` non-empty values corresponding to `a_indices`. a_shape: A `Tensor` of type `int64`. 1-D. Shape of the input SparseTensor. b_indices: A `Tensor` of type `int64`. counterpart to `a_indices` for the other operand. b_values: A `Tensor`. Must have the same type as `a_values`. counterpart to `a_values` for the other operand; must be of the same dtype. b_shape: A `Tensor` of type `int64`. counterpart to `a_shape` for the other operand; the two shapes must be equal. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values). output_indices: A `Tensor` of type `int64`. output_values: A `Tensor`. Has the same type as `a_values`. rNrrrrrrrr<r@)rArrBrCrrD_SparseSparseMaximumOutputr|rErFrGrHrI$sparse_sparse_maximum_eager_fallbackrKrNrOrLrPrQrSrTrrrrrrr<rVrWrXrYrZr[r\r]r^s r_sparse_sparse_maximumr z6    0h..0$ #\\  11 #T9h8W&g+009g n(88X'.)(0'N!QX QK' ""$3%%c* +F::L |VW> & , ,W 5' .-  & &- ##At,,  # #    1 Xw 8W  # #   03C==ED++EEEE10E1zraw_ops.SparseSparseMaximumctj||g|tjtjtj tj tjtjtjtjtjtjtjtjg \}} | \}}tj |tj}tj |tj}tj |tj}tj |tj}||||||g} d|f} tj"dd| | ||} tj$rtj&d| | | t(j+| } | S)Nr@sSparseSparseMaximumrrdr)rLrgrirrrrrrrjrrrrrrGrhrrPrTrr| rrrrrrr<r=rlrr^r]rXs r_rr s66(7KSSZSbSbdkdsdsu|vCvCELERERT[TaTacjcocoqxq~q~@G@P@PRYR`R`bibnbnpwp~p~@G@N@NSQR'9"8X$$Y >)  " "7GMM :'$$Y >)  " "7GMM :'Xw 8WM, >&   3Q|#)s ?' ""$ |VW> & , ,W 5' .rmSparseSparseMinimumTV_SparseSparseMinimum_Tc tjxstj}|j}|jr5 t j |d||||||| } t j| } | Stj d|||||||\} } } } | dd} t#j$r7d| j'df}| j(}t#j*d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||S#tj$rYwxYw)a,Returns the element-wise min of two SparseTensors. Assumes the two SparseTensors have the same shape, i.e., no broadcasting. Args: a_indices: A `Tensor` of type `int64`. 2-D. `N x R` matrix with the indices of non-empty values in a SparseTensor, in the canonical lexicographic ordering. a_values: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 1-D. `N` non-empty values corresponding to `a_indices`. a_shape: A `Tensor` of type `int64`. 1-D. Shape of the input SparseTensor. b_indices: A `Tensor` of type `int64`. counterpart to `a_indices` for the other operand. b_values: A `Tensor`. Must have the same type as `a_values`. counterpart to `a_values` for the other operand; must be of the same dtype. b_shape: A `Tensor` of type `int64`. counterpart to `a_shape` for the other operand; the two shapes must be equal. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values). output_indices: A `Tensor` of type `int64`. output_values: A `Tensor`. Has the same type as `a_values`. rNrrr@)rArrBrCrrD_SparseSparseMinimumOutputr|rErFrGrHrI$sparse_sparse_minimum_eager_fallbackrKrNrOrLrPrQrSrTrs r_sparse_sparse_minimumr rrzraw_ops.SparseSparseMinimumcrtj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}} | \}}t-j.|tj}t-j.|tj}t-j.|tj}t-j.|tj}||||||g} d|f} tj0dd| | ||} tj2rtj4d| | | t6j9| } | S)Nr@sSparseSparseMinimumrrdr)rLrgrirrrrrrrrjrrrrrrrrrrrrGrhrrPrTrr|rs r_rr8 sn66(7KSSZSbSbdkdsdsu|vCvCELERERT[TaTacjcocoqxqBqBDKDQDQSZS`S`bibpbpryr@r@BIBRBRT[TbTbdkdsdsu|uCuCELEWEWY`YeYegnguguw~wEwESHI'9"8X$$Y >)  " "7GMM :'$$Y >)  " "7GMM :'Xw 8WM, >&   3Q|#)s ?' ""$ |VW> & , ,W 5' .rm SparseSplit) TV_SparseSplit_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2 split_dim num_splitc tjxstj}|j}|jr5 t j |d|||||d| }t j|}|Stj |d}t#j$d||||||\} } } } | dd}tj&rHd| j)dd| j+df} | j,}tj.d|| ||d|g||dz}|dd|dd|zgz|d|zdz}|dd|ddgz}t j|}|S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t|||||||S#tj$rYRwxYw) aSplit a `SparseTensor` into `num_split` tensors along one dimension. If the `shape[split_dim]` is not an integer multiple of `num_split`. Slices `[0 : shape[split_dim] % num_split]` gets one extra dimension. For example, if `split_dim = 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] = shape = [2, 4] [ a ] [b c ] output_tensor[1] = shape = [2, 3] [ d e ] [ ] Args: split_dim: A `Tensor` of type `int64`. 0-D. The dimension along which to split. Must be in the range `[0, rank(shape))`. indices: A `Tensor` of type `int64`. 2-D tensor represents the indices of the sparse tensor. values: A `Tensor`. 1-D tensor represents the values of the sparse tensor. shape: A `Tensor` of type `int64`. 1-D. tensor represents the shape of the sparse tensor. output indices: A list of 1-D tensors represents the indices of the output sparse tensors. num_split: An `int` that is `>= 1`. The number of ways to split. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_indices, output_values, output_shape). output_indices: A list of `num_split` `Tensor` objects with type `int64`. output_values: A list of `num_split` `Tensor` objects with the same type as `values`. output_shape: A list of `num_split` `Tensor` objects with type `int64`. rrN)rr<r=)rrrrrr<r@rcr)rArrBrCrrD_SparseSplitOutputr|rErFrGrHrIsparse_split_eager_fallbackrKrLrrNrOrPrrQrSrT)rrrrrr<rVrWrXrYrZr[r\r]r^s r_ sparse_splitrP sT    0h..0$ #\\  11 mT9gvuY g#((1g n ;7)'88GF"idD!QX QK' ""$3,,[93  %'F::L |VW6 Zi !GIJ$7 7' BQK71Q]34 4wq9}~7N N' BQK712;- ''  $ $W -' .5  & &- ##At,,  # #    ( Wfeyt  # #   s03EF&FFFF00GGzraw_ops.SparseSplitctj|d}tj|g|g\}\}tj|t j }tj|t j }tj|t j }||||g}d|d|f} tjd||z|z|| ||} tjrtjd|| | | d|g| |dz} | dd| dd|zgz| d|zdz} | dd| ddgz} tj| } | S)Nrr@s SparseSplitrdrrcr) rLrrgrGrhrirjrrPrTrr|) rrrrrr<r=rlr^r]rXs r_rr sU ;7)66xbI'9F$$Y >)  " "7GMM :'   6%Wfe4, C 1&   ^Y-B&.'/;6!$4 1'""$ |VW6 Zi !GIJ$7 7' BQK71Q]34 4wq9}~7N N' BQK712;- ''  $ $W -' .rmTV_SparseTensorDenseAdd_T TV_SparseTensorDenseAdd_Tindicesbc tjxstj}|j}|jr t j |d|||||}|Stjd|||||\} } } } | dd}tj rHd| j#dd| j#df} | j$} tj&d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)aAdds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`. This Op does not require `a_indices` be sorted in standard lexicographic order. Args: a_indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2-D. The `indices` of the `SparseTensor`, with shape `[nnz, ndims]`. a_values: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. 1-D. The `values` of the `SparseTensor`, with shape `[nnz]`. a_shape: A `Tensor`. Must have the same type as `a_indices`. 1-D. The `shape` of the `SparseTensor`, with shape `[ndims]`. b: A `Tensor`. Must have the same type as `a_values`. `ndims`-D Tensor. With shape `a_shape`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a_values`. SparseTensorDenseAddNr)rrrrr<r@Tindices)rArrBrCrrDrErFrGrHrI&sparse_tensor_dense_add_eager_fallbackrKrNrOrLrPrQrSrT)rrrrr<rVrWrXrYrZr[r\r]r^s r_sparse_tensor_dense_addr sc&    0h..0$ #\\ 11 $dIx!Mg n(88)h(/14A!QX QK' ""$3%%c*J  ,.F::L  fg? (' .+  & &- ##At,,  # #    3 Xw$@@  # #   s0C$$D+7DD+*D+/EEEzraw_ops.SparseTensorDenseAddctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}}|\}}tj||g|tj tjg\}} | \}}||||g} d|d|f} tj,dd| | ||} tj.rtj0d| | | | \} | S)Nr@rsSparseTensorDenseAddrcrdr)rLrgrirrrrrrrrjrrrrrrrrrrrrrPrT) rrrrr<r=rlr_attr_Tindices_inputs_Tindicesr^r]rXs r_rr sF66!}cGOO]d]l]lnun{n{~E~K~KMTMZMZ\c\h\hjqj{j{}D}J}JLSLYLY[b[i[ikrkyky{B{K{KMTM[M[]d]l]lnun|n|~E~P~PRYR^R^`g`n`npwp~p~LAB'9-8Q%-%D%DiQXEY[^ahananpwp}p}aA&B".")9gXw2, *n 5&   4a #)s ?' ""$  fg? (' .rm) TV_SparseTensorDenseMatMul_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2#TV_SparseTensorDenseMatMul_Tindices adjoint_a adjoint_bc ptjxstj}|j}|jr" t j |d|||||d|d| } | S|d}tj|d}|d}tj|d}tj d|||||||\} } } } | dd} tj"rjd| j%dd | j%d d| j'dd| j'df}| j(}tj*d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||||S#t j$rYSwxYw) aMultiply SparseTensor (of rank 2) "A" by dense matrix "B". No validity checking is performed on the indices of A. However, the following input format is recommended for optimal behavior: if adjoint_a == false: A should be sorted in lexicographically increasing order. Use SparseReorder 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: a_indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2-D. The `indices` of the `SparseTensor`, size `[nnz, 2]` Matrix. a_values: A `Tensor`. 1-D. The `values` of the `SparseTensor`, size `[nnz]` Vector. a_shape: A `Tensor` of type `int64`. 1-D. The `shape` of the `SparseTensor`, size `[2]` Vector. b: A `Tensor`. Must have the same type as `a_values`. 2-D. A dense Matrix. adjoint_a: An optional `bool`. Defaults to `False`. 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: An optional `bool`. Defaults to `False`. 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 for the operation (optional). Returns: A `Tensor`. Has the same type as `a_values`. SparseTensorDenseMatMulrrN)rrr<r=F)rrrrrrr<r@r)rArrBrCrrDrErFrGrHrI*sparse_tensor_dense_mat_mul_eager_fallbackrKrLrrNrOrPrQrrSrT)rrrrrrr<rVrWrXrYrZr[r\r]r^s r_sparse_tensor_dense_mat_mulr sB    0h..0$ #\\ 11 'y(G ; ; ;gnI  K8)I  K8)'88!Y+2a9-6TC!QX QK' ""$3%%c*J  ,k  -{  -/F::L !<B (' .?  & &- ##At,,  # #    7 XwYDd44  # #   s0 EFE..FF FF54F5zraw_ops.SparseTensorDenseMatMulcB|d}tj|d}|d}tj|d}tj||g|g\}} | \}}tj|g|tjtj gtj \} \}t j|tj }||||g} d|d| d|d|f} tjdd| | ||} tjrtjd | | | | \} | S) NFrrr@rsSparseTensorDenseMatMulrcrdr) rLrrgrirrjrGrhrrPrT)rrrrrrr<r=rlrrr^r]rXs r_rrN s4I  K8)I  K8)66!}c2N'9-8Q!)!@!@)cT[TaTacjcpcpSsu|vCvC"D.,9  " "7GMM :'Xw2, *nk9 y &   7$0C"& ('""$ !<B (' .rm) TV_SparseToDense_Trrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2TV_SparseToDense_Tindicesvalidate_indicesc tjxstj}|j}|jr t j |d|||||d| }|S|d}tj|d}tj d||||||\} } } } | dd}tj"rYd| j%dd| j'dd| j'df} | j(}tj*d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rY&wxYw) aConverts a sparse representation into a dense tensor. Builds an array `dense` with shape `output_shape` such that ``` # 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 `Tensor`. Must be one of the following types: `int32`, `int64`. 0-D, 1-D, or 2-D. `sparse_indices[i]` contains the complete index where `sparse_values[i]` will be placed. output_shape: A `Tensor`. Must have the same type as `sparse_indices`. 1-D. Shape of the dense output tensor. sparse_values: A `Tensor`. 1-D. Values corresponding to each row of `sparse_indices`, or a scalar value to be used for all sparse indices. default_value: A `Tensor`. Must have the same type as `sparse_values`. Scalar value to set for indices not specified in `sparse_indices`. validate_indices: An optional `bool`. Defaults to `True`. 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: A `Tensor`. Has the same type as `sparse_values`. SparseToDenserN)rr<r=T)r3rr4rDrr<r@r)rArrBrCrrDrErFrGrHrIsparse_to_dense_eager_fallbackrKrLrrNrOrPrrQrSrT)r3rr4rDrr<rVrWrXrYrZr[r\r]r^s r_sparse_to_denseri sV    0h..0$ #\\ 11 ot^\}&8:JLgn''(8:LM'88&2'4'4*: G!QX QK' ""$ #"4"45G"H#  %z  ,.F::L vw8 (' .;  & &- ##At,,  # #    + , }+$DBB  # #   s0DE%EEEE//FFzraw_ops.SparseToDensec|d}tj|d}tj||g|g\}}|\}}tj||g|tjtj g\} } | \}}||||g} d|d|d| f} tj dd| | ||} tjrtjd| | | | \} | S) NTrr@rs SparseToDensercrdr) rLrrgrirrjrrPrT)r3rr4rDrr<r=rlrrrr^r]rXs r_rr s''(8:LM66 }7UWZ\^_'9#, =-%-%D%DnVbEcehkrkxkx{B{H{HkK&L"."#3 >< , }M,  0#w  &   -q#)s ?' ""$ vw8 (' .rmTakeManySparseFromTensorsMap) %TV_TakeManySparseFromTensorsMap_dtyperrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2sparse_handlesc tjxstj}|j}|jr6 t j |d||d|d|d| }t j|}|Stj |d}|d}tj"|d}|d}tj"|d}t%j&d|||||\} } } } | dd}tj(rYd| j+dd| j-dd| j-df} | j.} tj0d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||||S#tj$rYewxYw) a Read `SparseTensors` from a `SparseTensorsMap` and concatenate them. The input `sparse_handles` must be an `int64` matrix of shape `[N, 1]` where `N` is the minibatch size and the rows correspond to the output handles of `AddSparseToTensorsMap` or `AddManySparseToTensorsMap`. The ranks of the original `SparseTensor` objects that went into the given input ops 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 on the left). 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 `SparseReorder` to restore index ordering. For example, if the handles represent an input, which 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 `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_handles: A `Tensor` of type `int64`. 1-D, The `N` serialized `SparseTensor` objects. Shape: `[N]`. dtype: A `tf.DType`. The `dtype` of the `SparseTensor` objects stored in the `SparseTensorsMap`. container: An optional `string`. Defaults to `""`. The container name for the `SparseTensorsMap` read by this op. shared_name: An optional `string`. Defaults to `""`. The shared name for the `SparseTensorsMap` read by this op. It should not be blank; rather the `shared_name` or unique Operation name of the Op that created the original `SparseTensorsMap` should be used. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (sparse_indices, sparse_values, sparse_shape). sparse_indices: A `Tensor` of type `int64`. sparse_values: A `Tensor` of type `dtype`. sparse_shape: A `Tensor` of type `int64`. rrwr6r7N)rwr6r7r<r=r>)rrwr6r7r<)rArrBrCrrD#_TakeManySparseFromTensorsMapOutputr|rErFrGrHrI0take_many_sparse_from_tensors_map_eager_fallbackrKrLr~rMrNrOrPrQrRrSrT)rrwr6r7r<rVrWrXrYrZr[r\r]r^s r_!take_many_sparse_from_tensors_mapr sT    0h..0$ #\\  11 ,dNG {I}kCg499'Bg n   UG ,%I ;7)K!!+}=+'88&~.3y4?dL!QX QK' ""$s))'2Kll;'ll=)+F::L & fgG / 5 5g >' .?  & &- ##At,,  # #    = !$88  # #   s04E((F/;FF/.F/3GGGz$raw_ops.TakeManySparseFromTensorsMapctj|d}|d}tj|d}|d}tj|d}tj|t j }|g}d|d|d|f}tjdd||||}tjrtjd|||tj|}|S) Nrwr>r6r7sTakeManySparseFromTensorsMaprrdr) rLr~rMrGrhrirjrrPrTrr|) rrwr6r7r<r=r^r]rXs r_rrO s   UG ,%I ;7)K!!+}=+)).'--H. !, UKM  &   ' .rm)r>r>N)N)FN)FFN)TN)__doc__ collectionstensorflow.pythonrtensorflow.python.eagerrrArrErrLtensorflow.python.frameworkrritensorflow.security.fuzzing.pyr_atypesr _op_def_registryr rGr rN"tensorflow.python.util.deprecationr tensorflow.python.utilr _dispatch tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsrrInt64strr` to_raw_opr:rJrnrrrprq namedtupler{ruStringrrtr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrintrrrrrrrrrrrBoolrr rrr!rr r#r-r)r+r3r7r5r6r9r=r;r<rFrBrHr?rGrQrNrSrKrRrUInt32rar\r_rirgrkrfrjrorsrqrrrxrvrzruryrr}rr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmr_rs : 67179FK3IC86%%'!("` V9S'--=O3PVajknqOlObPV`ijmovo|o|j|`}VILV]`Vs|}@BIBOBO}OsPVpKI&IJ>4>>ZxKyz)CQXQ^Q^L^B_pyz}@^{^q_oxy|~E~K~KyKoLY\kn~GHKMTMZMZHZ~[,%X JiW]]8J.KJ\efilFgF]GJW`adfmfsfsasWtJ@CJTWJjstwy@yFyFtFjGJXC "AB>4>>RkClmYsGMMGY=Zktux{UvUlVfopsu|uBuBpBfCPSbeu~BDKDQDQQuR( 6{557 9 ")"` Yygnn9L/MYVtYvC "AB>4>>RiCjk iW^^H[>\ fD 2;1179 %X #*+MO_ar#s Y)C9Y4Y*ZYc}Yv;I9:>4>>J\;]^ 3HhCh9i sM #T ")*KM]_p"qY`YgYgnr=)C4F*G=XabegbYA=QZ[^`g`m`m[mQn=yX=w@ADFeAewf=~?i =>~t~~Nc?de3 CU9VgpqtwOrOhP`ijmovo|o|j|`}IhxABEGfBfxg$L %&CEUWhiLSLZLZae4YsGMM/A%B4S\]`bv]vSw4HQRUW^WdWdRdHe4pK4jstwyTtTjU4l7)56~t~~FV7WXIc7==>P4QbklorFmFcGW`adfmfsfsasWt@[ktuxzUuUkV"*;)).0 )+=?SUhj{~OQ_aprACRTbdtvFHWYjl|~NP`brtCD13EGXZkm{~MO^`oqAQSceuwFGJ)C$67J9SR`M`CaJluvy|C|I|IwImJJW`adfmfsfsasWtJ@IJMO]J]@^JirsvxxExEsEiFJPYZ]_qZqPrJX +I) *>4>>*+E F 3 3E)FR[\_ao\oRp|EFIKRKXKXFX|Yfopsu|uBuBpBfCOXY\^lYlOmxABEGNGTGTBTxU_hiln@i@_A$.{--< " 13EG[]psDFWYgixzIKZ\jl|~NP_artDFVXhjz|KL:y6H1H'I:V_`celerer`rVs:AJKNPWP]P]K]A^:mvwz|C|I|IwImJ:x3 12>4>>/3RS  iEW@W6X enort{uBuBpBfC PYZ]_f_l_lZlPm |EFIKRKXKXFX|Y -k,,79 F v9T#Y %=>v RVWZR[]nRnHovzCDHILDMOVO\O\D\z]vknvp1y/0 1NO $)DIw}}4L*M$W`aefiajl}a}W~$IRSWX[S\^e^k^kSkIl$z}$L,[++79 "";_N^_&'EXhiB)DIw}}$<=ByY]^aYbdkdqdqYqOrBRVBehBtwBCZBkGBH/i-.~t~~l/KL #49gmm3K)L#^ghlmphqsztAtAiA_B#ae#tw#CF#Ri#zV#J2;1179 q49gmm+C!DqV_`deh`ikrkxkx`xVyqW`adfmfsfsasWtqCLMPRYR^R^M^C_qgpqtv}vCvCqCgDqf;I9:>4>>J];^_ $s)W]]:R0Senostwox{B{H{HpHfIfopsu|uBuBpBfCR[\_ahamam\mRnv@CELERER@RvSB.{--79 iYtCy'--'?@iR[\`ad\egngtgt\tRuiKTUXZaZhZhUhKiiV3 12>4>>/3RS Id3i6N,Oajkopsktv}wDwDlDbEZcdgipiwiwdwZx@##=?QSgi|PRcesuDFUWfhvxHJZ\km~@PRbdtvFHWX7ygmm1C'D7QZ[^`x[xQy7FOPSU\UbUbPbFc7luvy{SvSlT7dmnqsKnKdL7r?i =>~t~~Nd?ef iW]]@R6S `ijmpHkHaI U^_bdkdqdq_qUr {DEHJbEb{c s|}@BZ}Zs[  ##=?QSgi|PRcesuDFUWfhvxHJZ\km~@PRbdtvFHWX1ygmm1C'D1QZ[^`x[xQy1FOPSU\UbUbPbFc1luvy{SvSlT1dmnqsKnKdL1f?i =>~t~~Nd?ef iW]]@R6S `ijmpHkHaI U^_bdkdqdq_qUr {DEHJbEb{c s|}@BZ}Zs[  ##=?QSgi|PRcesuDFUWfhvxHJZ\km~@PRbdtvFHWX5ygmm1C'D5QZ[^`x[xQy5FOPSU\UbUbPbFc5luvy{SvSlT5dmnqsKnKdL5n?i =>~t~~Nd?ef iW]]@R6S `ijmpHkHaI U^_bdkdqdq_qUr {DEHJbEb{c s|}@BZ}Zs[ 4[33SU #T ZIc7==.@$AZ9UXZrUrKsZCLMPRYR_R_M_C`Zqz{~@X{XqYZx?i =>~t~~Nd?ef 9S'--=O3P ZcdgjBeB[C R[\_ahanan\nRo @IJMOgJg@h "8!7!7"#"% ' \ 49S'--=O3P4_hiloKjK`L4lG)$EF~t~~VqGrs )CQXQ^Q^L^B_ nwx{~ZyZo[ 57IK\^oqBQSbdsuCEUWgiy{JKDYsGMM/A%BDR[\_au\uRvDFOPSU\UbUbPbFcDu~BDKDQDQQuRD^bDxABEG[B[x\DL7)56~t~~FW7XYIc7==>P4QajknqElEbFU^_bdkdqdq_qUrDMNQSZS`S`N`DanrBKLOQeLeBf$ 6{557 9 %%ACUWhj{~LN]_npAOQacsuEGVWJIc7==6H,IJYbcfiCdCZDJS\]`bibobo]oSpJBKLOQXQ^Q^L^B_JkoJXC "AB>4>>RjCkl9S'--EW;XhqruxRsRiSbkloqxq~q~l~bQZ[^`g`m`m[mQn{&57IK_atwHJ[]km|~MO^`np@BRTcevxHJZ\ln~@OPDYsGMM/A%BDR[\_au\uRvDFOPSU\UbUbPbFcDu~BDKDQDQQuRD^bDxABEG[B[x\DL7)56~t~~FW7XYIc7==>P4QajknqElEbFU^_bdkdqdq_qUrDMNQSZS`S`N`DanrBKLOQeLeBf$ 6{557 9 %%ACUWknACTVgiwyHJY[jlz|LN^`oqBDTVfhxzJL[\JIc7==6H,IJYbcfiCdCZDJS\]`bibobo]oSpJBKLOQXQ^Q^L^B_JkoJXC "AB>4>>RjCkl9S'--EW;XhqruxRsRiSbkloqxq~q~l~bQZ[^`g`m`m[mQn{$.{--') H 9)C,>"?9yY\^pYpOq9AJKNPWP]P]K]A^9v3 12>4>>.3QR  3 ;M1N ^ghkmh_A PYZ]_f_l_lZlPm .{--~&( ?)C,>"??iX[]d]j]jXjNk?yBCFHOHUHUCUyV?B3 12>4>>.3QR  3 ;M1N ]fgjlslylygy]z HQRUW^WdWdRdHe ,[++79 D D)C$67D3P`K`AaDjstwzAzGzGuGkHDQZ[^`g`m`m[mQnDv@CELERER@RvSDL/i-.~t~~l/KL 3 3E)FPYZ]_oZoPpzCDGIPIVIVDVzW`ijmovo|o|j|`}ENORT[TaTaOaEb"57IK_atwHJ[]km|~MO^`np@BRTcevxHJZ\ln~@OP538L3L)M5^ghkmtmzmzhz^{5KTUXZaZgZgUgKh5zCDGIPIVIVDVzW5gpqtvJqJgK5n7)56~t~~FW7XY  #G[B[8\ mvwz}D}J}JxJnK ZcdgipivivdvZw IRSVX_XeXeSeIf v@CEY@YvZ  13DFWYgh;ygmm);<;SVXjSjIk;xABEGNGTGTBTxU;enortFoFeG;z3 12>4>>.3QR  iW]]8J.K XabegybyXz GPQTV]VcVcQcGd t}~ACU~UtV 4[33') ##=?QSdfwzHJY[jl{}KM]_oqACRS:YsGMM/A%B:iX[]uXuNv:BKLOQXQ^Q^L^B_:luvy{B{H{HvHlI:U^_bd|_|U}:HQRUW^WdWdRdHe:x?i =>~t~~Nc?deIc7==>P4Q]fgjmEhE^FQZ[^`g`m`m[mQn{DEHJQJWJWEW{XdmnqsKnKdLW`adfmfsfsasWt"4[33') ##=?QSgi|PRcesuDFUWfhvxHJZ\km~@PRbdtvFHWX:YsGMM/A%B:iX[]uXuNv:BKLOQXQ^Q^L^B_:luvy{B{H{HvHlI:U^_bd|_|U}:HQRUW^WdWdRdHe:x?i =>~t~~Nc?deIc7==>P4Q]fgjmEhE^FQZ[^`g`m`m[mQn{DEHJQJWJWEW{XdmnqsKnKdLW`adfmfsfsasWt",[++79 D MIc7==&89MIcSZS`S`N`DaMktux{KvKlLMU^_bdkdqdq_qUrMBM^/i-.~t~~l/KL 9S'--5G+HS\]`bibobo]oSp{DEHJZEZ{[dmnqszs@s@n@dANQ*$$?ASUik~ARTeguwFHWYhjxzJL\^mo@BRTdfvxHJYZ#*+M`o#p /y6V1V'W/clmpsLnLdM/XabegGbGXH/MVWZ\uWuMv/FOPSUnPnFo/bAy!?@PgAhi iEe@e6f r{|B[}[s\ gpqtvVqVgW \efikDfD\E U^_bd}_}U~  ' \ &-.SUdfu&v#H9S:]5]+^HjstwzVuVkWHbkloqxq~q~l~bHDMNQSoNoDpH|@HRVHluvy{WvWlXHTG)$EF~t~~VqGrs)CIlDl:mzCDGIeDezfqz{~@G@M@M{MqNS\]`b~]~SLP]aqz{~@\{\q]0H #$?RabPIc3L.L$MP]fgjmFhF^GPXabegybyXzPKTUXZlUlKmP@DPYbcfhzczY{Pd3 12>4>>/3RS 9SB[=[3\luvy|UwUmVgpqtvHqHgIZcdgi{d{Z|PTdmnqsEnEdF&'=k&<&<"7'9# )0)n %riW]]@R6Sr]BrNQrberh Qy)OPQ_QUQ_Q_aBRC DYsT[TaTaOaEblQ^apsrm