AVhlz dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#ejHdddgZ%edZ&edddZ'e jPdfde#e!ejRfde*de*de&de'f dZ+edejXe+Z-de#e!ejRfde*de*de&de'f dZ.ejHd gd!Z/ed"Z0ed#ddZ1dBd$e#e e!e1fd%e#e!e0ffd&Z2ed'ejXe2Z3d$e#e e!e1fd%e#e!e0ffd(Z4ed)Z5ed*ddZ6ed+ddZ7dBd,e#e!e7fd-e#e!e5fd.e#e!e5fd/e#e e!e6fd0e#e!e5ff d1Z8ed2ejXe8Z9d,e#e!e7fd-e#e!e5fd.e#e!e5fd/e#e e!e6fd0e#e!e5ff d3Z:ed4Z;ed5ddZed8ejXe>Z?d$e#e e!ee#e!ejfdeAd0e#e!eAff d?ZDed@ejXeDZEde#e!ejfdeAd0e#e!eAff dAZFy)CzUPython 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) AnnotatedRaggedTensorFromVariantoutput_nested_splitsoutput_dense_values) "TV_RaggedTensorFromVariant_Tvalues_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.Variant"TV_RaggedTensorFromVariant_Tsplitsr%r'encoded_raggedinput_ragged_rankoutput_ragged_rankTvaluesTsplitsc>tjxstj}|j}|jr8 t j |d||d|d|d|d| }t j|}|Stj |d}tj |d}tj"|d}|t$j&}tj"|d}t)j*d||||||\} } } } | dd}tj,rjd| j/dd| j/dd| j1dd| j1df} | j2}tj4d|| ||d|g||dz}t j|}|S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t|||||||S#tj$rYwxYw) a-Decodes a `variant` Tensor into a `RaggedTensor`. Decodes the given `variant` Tensor and returns a `RaggedTensor`. The input could be a scalar, meaning it encodes a single `RaggedTensor` with ragged_rank `output_ragged_rank`. It could also have an arbitrary rank, in which case each element is decoded into a `RaggedTensor` with ragged_rank `input_ragged_rank` and these are then stacked according to the input shape to output a single `RaggedTensor` with ragged_rank `output_ragged_rank`. Each `variant` element in the input Tensor is decoded by retrieving from the element a 1-D `variant` Tensor with `input_ragged_rank + 1` Tensors, corresponding to the splits and values of the decoded `RaggedTensor`. If `input_ragged_rank` is -1, then it is inferred as `output_ragged_rank` - `rank(encoded_ragged)`. See `RaggedTensorToVariant` for the corresponding encoding logic. Args: encoded_ragged: A `Tensor` of type `variant`. A `variant` Tensor containing encoded `RaggedTensor`s. input_ragged_rank: An `int` that is `>= -1`. The ragged rank of each encoded `RaggedTensor` component in the input. If set to -1, this is inferred as `output_ragged_rank` - `rank(encoded_ragged)` output_ragged_rank: An `int` that is `>= 0`. The expected ragged rank of the output `RaggedTensor`. The following must hold: `output_ragged_rank = rank(encoded_ragged) + input_ragged_rank`. Tvalues: A `tf.DType`. Tsplits: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_nested_splits, output_dense_values). output_nested_splits: A list of `output_ragged_rank` `Tensor` objects with type `Tsplits`. output_dense_values: A `Tensor` of type `Tvalues`. rr8r9r:r;N)r8r9r:r;namectx)r7r8r9r:r;r=)_contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_RaggedTensorFromVariantOutput_make_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException)ragged_tensor_from_variant_eager_fallback_SymbolicException_executemake_int make_type_dtypesint64_op_def_library_apply_op_helpermust_record_gradient _get_attr_int_get_attr_typeinputsrecord_gradient)r7r8r9r:r;r=_ctxtld_resulte__op_outputs_attrs _inputs_flats _/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_ragged_conversion_ops.pyragged_tensor_from_variantrb s7D    0h..0$ #\\  11 '~.0DIw 7Dg/44W=g n''(9;NO(();=QR   w 2' _mmG   w 2''88!.5F6H+2G(, .!QX QK' ""$!3#4#45H#I"C$5$56J$K++I6   +-F::L !<B (( ) *W5G5H-I I' * 0 0 9' .G  & &- ##At,,  # #    6 ,=/$00  # #   s06F((G/;GG/.G/3HHHzraw_ops.RaggedTensorFromVariantctj|d}tj|d}tj|d}|tj}tj|d}t j |tj}|g}d|d|d|d|f}tjd|dz||||} tjrtjd||| | d|g| |dz} tj| } | S) Nr8r9r:r;sRaggedTensorFromVariantrVattrsr>r=r) rLrMrNrOrPrGconvert_to_tensorvariantrrSrWrCrD) r7r8r9r:r;r=r>r`r_rZs rarJrJts''(9;NO(();=QR   w 2' _mmG   w 2')).'//J. !, !24Hi)W >&   79K:'36s"& ('""$ !<B (( ) *W5G5H-I I' * 0 0 9' .RaggedTensorToSparse)sparse_indices sparse_valuessparse_dense_shape) TV_RaggedTensorToSparse_Trrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5TV_RaggedTensorToSparse_Tsplitsrt_nested_splitsrt_dense_valuescttjxstj}|j}|jr1 t j |d|||}t j|}|St|t t"fst%d|zt'|}t)j*d|||\}}} } | dd}t-j.rYd| j1dd| j3dd| j3df} | j4} t-j6d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||S#tj$rYFwxYw) a0Converts a `RaggedTensor` into a `SparseTensor` with the same values. input=ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits) output=SparseTensor(indices=sparse_indices, values=sparse_values, dense_shape=sparse_dense_shape) Args: rt_nested_splits: A list of at least 1 `Tensor` objects with the same type in: `int32`, `int64`. The `row_splits` for the `RaggedTensor`. rt_dense_values: A `Tensor`. The `flat_values` for the `RaggedTensor`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (sparse_indices, sparse_values, sparse_dense_shape). sparse_indices: A `Tensor` of type `int64`. sparse_values: A `Tensor`. Has the same type as `rt_dense_values`. sparse_dense_shape: A `Tensor` of type `int64`. rjN)r=r>VExpected list for 'rt_nested_splits' argument to 'ragged_tensor_to_sparse' Op, not %r.)rprqr= RAGGED_RANKTr;)r?rr@rArrB_RaggedTensorToSparseOutputrDrErFrGrHrI&ragged_tensor_to_sparse_eager_fallbackrK isinstancelisttuple TypeErrorlenrQrRrLrSrTrUrVrW) rprqr=rXrYrZr[_attr_RAGGED_RANKr\r]r^r_r`s raragged_tensor_to_sparser~s(    0h..0$ #\\ 11 $d,r}_attr_T _attr_Tsplitsr`r_rZs rarwrws, $tUm 4  02B C DD*+ ( ? ?@QSVXZ [' O$,$C$CDIYDZ\_biboboqxq~q~bBDKDQDQ%R!-!&'?*;;, ,c7I &   4a #)s ?' ""$  fg? ' - -g 6' .ri) TV_RaggedTensorToTensor_Trrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5TV_RaggedTensorToTensor_TindexTV_RaggedTensorToTensor_Tshapeshapevalues default_valuerow_partition_tensorsreturnc tjxstj}|j}|jr t j |d|||||d| }|St|ttfst!d|zt#|} t|ttfst!d|z|D cgc]} t%j&| d}} t)j*d||||||\} } } }|dd}t%j,r{d| j/dd | j/d d | j/d d | j1d d| j3df }| j4}t%j6d||||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYwxYwcc} w) a Create a dense tensor from a ragged tensor, possibly altering its shape. The `ragged_to_dense` op creates a dense tensor from a list of row partition tensors, a value vector, and default values. If the shape is unspecified, the minimal shape required to contain all the elements in the ragged tensor (the natural shape) will be used. If some dimensions are left unspecified, then the size of the natural shape is used in that dimension. The default_value will be broadcast to the output shape. After that, the values from the ragged tensor overwrite the default values. Note that the default_value must have less dimensions than the value. The row partition tensors are in the order of the dimensions. At present, the types can be: * "ROW_SPLITS": the row_splits tensor from the ragged tensor. * "VALUE_ROWIDS": the value_rowids tensor from the ragged tensor. * "FIRST_DIM_SIZE": if value_rowids is used for the first dimension, then it is preceded by "FIRST_DIM_SIZE". Args: shape: A `Tensor`. Must be one of the following types: `int64`, `int32`. The desired shape of the output tensor. If left unspecified (empty), the minimal shape required to contain all the elements in the ragged tensor (the natural shape) will be used. If some dimensions are left unspecified, then the size of the natural shape is used in that dimension. Note that dense dimensions cannot be modified by the shape argument. Trying to change the size of a dense dimension will cause the op to fail. Examples: natural shape: [4, 5, 6] shape: -1 output shape: [4, 5, 6] natural shape: [4, 5, 6] shape: [3, -1, 2] output shape: [3, 5, 2] natural shape: [4, 5, 6] shape: [3, 7, 2] output shape: [3, 7, 2] values: A `Tensor`. A 1D tensor representing the values of the ragged tensor. default_value: A `Tensor`. Must have the same type as `values`. The default_value when the shape is larger than the ragged tensor. The default_value is broadcast until it is the shape of the output tensor, and then overwritten by values in the ragged tensor. The default value must be compatible with this broadcast operation, and must have fewer dimensions than the value tensor. row_partition_tensors: A list of at least 1 `Tensor` objects with the same type in: `int64`, `int32`. row_partition_types: A list of `strings`. The types of the row partition tensors. At present, these can be: * "ROW_SPLITS": the row_splits tensor from the ragged tensor. * "VALUE_ROWIDS": the value_rowids tensor from the ragged tensor. * "FIRST_DIM_SIZE": if value_rowids is used for the first dimension, then it is preceeded by "FIRST_DIM_SIZE". The tensors are in the order of the dimensions. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `values`. RaggedTensorToTensorrow_partition_typesN)rr=r>[Expected list for 'row_partition_tensors' argument to 'ragged_tensor_to_tensor' Op, not %r.YExpected list for 'row_partition_types' argument to 'ragged_tensor_to_tensor' Op, not %r.)rrrrrr=ruTindexTshapenum_row_partition_tensors)r?rr@rArrBrErFrGrHrI&ragged_tensor_to_tensor_eager_fallbackrKrxryrzr{r|rLmake_strrQrRrSrUrTget_attrrVrW)rrrrrr=rXrYrZr[_attr_num_row_partition_tensors_sr\r]r^r_r`s raragged_tensor_to_tensorrs=|    0h..0$ #\\ 11 $dE6=46IKgn )D%= 9  02G H II%((=$>! '$ 7  02E F GGQdd"**2/DEdd'88eF.;6K4G%) +!QX QK' ""$3%%c*H  *H  *,G ;<#S\\2G%H JF ::L  fg? (' .M  & &- ##At,,  # #    3 (=1$HH  # #   es6F6HG#F>>GGG--HHzraw_ops.RaggedTensorToTensorc t|ttfstd|zt |}t|ttfstd|z|Dcgc]}t j |d}}t j||g|g\} } | \}}t jt||tjtjg\} }t j|g|tjtjg\} \}|||gt|z} d| d| d| d|d|f }t jdd | ||| }t jrt jd | |||\}|Scc}w) NrrrrurrrsRaggedTensorToTensorrdrer)rxryrzr{r|rLrrrOrPrrrSrW)rrrrrr=r>rrr _inputs_T _attr_Tindex _attr_Tshaper`r_rZs rarrVs )D%= 9  02G H II%((=$>! '$ 7  02E F GGQdd"**2/DEdd66 7NPSUWX'9%6=(0(G(GMbHcehkrkxkx{B{H{HkK)L%,%#::E7C'--Y`YfYfIij,/$7L2MM, (L(L>, .&   4a #)s ?' ""$  fg? (' .esE>) TV_RaggedTensorToVariant_Tvaluesrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5 TV_RaggedTensorToVariant_Tsplits batched_inputc ~tjxstj}|j}|jr t j |d|||d|}|St|ttfst!d|zt#|}t%j&|d}t)j*d||||\} } } } | dd}t%j,rjd| j/dd| j1dd | j1d d| j3df} | j4} t%j6d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||S#t j$rY^wxYw) aEncodes a `RaggedTensor` into a `variant` Tensor. Encodes the given `RaggedTensor` and returns a `variant` Tensor. If `batched_input` is True, then input `RaggedTensor` is unbatched along the zero-th dimension, each component `RaggedTensor` is encoded into a scalar `variant` Tensor, and these are stacked to return a 1-D `variant` Tensor. If `batched_input` is False, then the input `RaggedTensor` is encoded as is and a scalar `variant` Tensor is returned. A `RaggedTensor` is encoded by first creating a 1-D `variant` Tensor with `ragged_rank + 1` elements, containing the splits and values Tensors of the `RaggedTensor`. Then the 1-D `variant` Tensor is wrapped in a scalar `variant` Tensor. See `RaggedTensorFromVariant` for the corresponding decoding logic. Args: rt_nested_splits: A list of `Tensor` objects with the same type in: `int32`, `int64`. A list of one or more Tensors representing the splits of the input `RaggedTensor`. rt_dense_values: A `Tensor`. A Tensor representing the values of the input `RaggedTensor`. batched_input: A `bool`. A `bool` denoting whether the input is a batched `RaggedTensor`. name: A name for the operation (optional). Returns: A `Tensor` of type `variant`. RaggedTensorToVariantrN)rr=r>WExpected list for 'rt_nested_splits' argument to 'ragged_tensor_to_variant' Op, not %r.)rprqrr=rtr:r;)r?rr@rArrBrErFrGrHrI'ragged_tensor_to_variant_eager_fallbackrKrxryrzr{r|rL make_boolrQrRrSrTrU_get_attr_boolrVrW)rprqrr=rXrYrZr[r}r\r]r^r_r`s raragged_tensor_to_variantrus8    0h..0$ #\\ 11 %t-=-9gn $tUm 4  13C D EE*+$$]OD-'882B1@/<4I!QX QK' ""$S..}=y  +Y  +_  13F::L vw@ (' .?  & &- ##At,,  # #    4 O=  # #   s0E FE88FFF%%F<;F<zraw_ops.RaggedTensorToVariantc2t|ttfstd|zt |}t j |d}t j|g|g\}\}t jt||tjtjgtj\}}t||gz}d|d|d|d|f} t jdd|| ||} t jrt jd || | | \} | S) Nrrrtr:r;sRaggedTensorToVariantrdrer)rxryrzr{r|rLrrrOrrPrrSrW) rprqrr=r>r} _attr_Tvaluesrr`r_rZs rarrs: $tUm 4  13C D EE*+$$]OD-&.&E&EFWY\^`&a#-#/$,$C$CDIYDZ\_biboboqxq~q~bBDKDQDQ%R!-!&'?*;;, ,i ]O] <&   5q#)s ?' ""$ vw@ (' .ri) (TV_RaggedTensorToVariantGradient_Tvaluesrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5(TV_RaggedTensorToVariantGradient_Tsplitsencoded_ragged_grad row_splitsdense_values_shapec tjxstj}|j}|jr t j |d||||d|}|Stj|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)aHelper used to compute the gradient for `RaggedTensorToVariant`. Computes the gradient for the dense_values input to the RaggedTensorToVariant op, given the variant-encoded ragged gradients of the outputs, along with the outer row-splits and the shape of the dense-values that were provided as inputs to the RaggedTensorToVariant op. Args: encoded_ragged_grad: A `Tensor` of type `variant`. A `variant` Tensor containing encoded `RaggedTensor` gradients. row_splits: A `Tensor`. Must be one of the following types: `int32`, `int64`. Outermost row-splits that were used as input to the RaggedTensorToVariant op. dense_values_shape: A `Tensor` of type `int32`. Shape of the dense_values that was used as an input to the RaggedTensorToVariant op. Tvalues: A `tf.DType`. name: A name for the operation (optional). Returns: A `Tensor` of type `Tvalues`. RaggedTensorToVariantGradientr:N)r:r=r>)rrrr:r=r;)r?rr@rArrBrErFrGrHrI0ragged_tensor_to_variant_gradient_eager_fallbackrKrLrNrQrRrSrUrVrW)rrrr:r=rXrYrZr[r\r]r^r_r`s ra!ragged_tensor_to_variant_gradientrs,    0h..0$ #\\ 11 -t5H& 7rr`r_rZs rarrs   w 2'!)!@!@*sU\UbUbdkdqdqTtv}wDwD"E-*../BGOOT--.@'--P%z3EF, w = 9&   =q$0C"& ('""$ 'vwH (' .ri)N)G__doc__ collectionstensorflow.pythonrtensorflow.python.eagerrr?rrErrLtensorflow.python.frameworkrrOtensorflow.security.fuzzing.pyr_atypesr _op_def_registryr rGr rQ"tensorflow.python.util.deprecationr tensorflow.python.utilr _dispatch tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsr namedtuplerCrr6rPVariantintrb to_raw_oprrJrvrnror~rjrwrrrrrrrrboolrrrrrInt32rrrrirars 67179FK3IC86%%'!7!7!723"5 &-&h "%,-QSbds%t"ZaZgZgnrOygoo9M/NOcfO|OKmOwYObG)$EF~t~~VpGqriW__H\>]ruLOZ|Gi*5k44=? $V ")*K_^m"n7iS Cb8b.c7vADF_A_w`7rAy!?@PgAhiYtCyRqGq=rFOPSUnPnFo($V !()I?\k!l!()I?\k!ll9S2P-P#Ql[dehkDfD\ElV_`ce~`~VlXabfgjbkmKbKXLlqz{~@Y{YqZl\Ay!?@PgAhi)CA_<_2`jstwzSuSkTenortMoMeNgpquvyqz|ZqZg[@IJMOhJh@i8$+$d #*+M`o#p CycDd9d/eCyBCFHhChyiCz~CNWX[]d]l]lXlNmCJC "AB>4>>RjCkliS SsHs>tHQRUWwRwHxIM]fgjlsl{l{g{]|*,3,t (+23]_np,A(79S'//EY;Z7hqrux`s`ia7w@ADFMFSFSASwT7_G7W`adfNaNWO7r!S *Q RSaSWSaSacDTE!F)TWY`YhYhThJixABEGoBoxpFOPSU\UbUbPbFcnVfopsu]p]f^ri