AVh \ dZddlmZddlmZddlmZddlmZddlmZddlmZ ddlm Z dd lm Z dd l m Z dd l mZdd l mZdd l mZddl mZddl mZddl mZddl mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"e"de jFdIdZ$e jJe jLdIdejNfdZ&dId Z(dId!Z)e jJe jTdIdejNfd"Z+e jJe jV dJdejNfd#Z,e jJe jZej\dfdejNfd$Z/e jJe j^dej\fdejNfd%Z0e jJe jbdIdejNfd&Z1e jJe jd dKd'ejNfd(Z3e"d)e jFdId*Z4e jJe jjdId+ejNfd,Z5e"d-e jFdId.Z6e"d/e jFdLd0Z7d1Z8 dMd2Z9dId3Z:ejvd4d5Z<e jJejz dId6ej|d7ej|fd8Z=e jJe j~ dLd9ejNfd:Z?e jJe jd+ej|d;ejdZEe jJe jdej\fdejNd?eeHd>> # Aliases for True & False so data and mask line up. >>> T, F = (True, False) >>> tf.ragged.boolean_mask( # Mask a 2D Tensor. ... data=[[1, 2, 3], [4, 5, 6], [7, 8, 9]], ... mask=[[T, F, T], [F, F, F], [T, F, F]]).to_list() [[1, 3], [], [7]] >>> tf.ragged.boolean_mask( # Mask a 2D RaggedTensor. ... tf.ragged.constant([[1, 2, 3], [4], [5, 6]]), ... tf.ragged.constant([[F, F, T], [F], [T, T]])).to_list() [[3], [], [5, 6]] >>> tf.ragged.boolean_mask( # Mask rows of a 2D RaggedTensor. ... tf.ragged.constant([[1, 2, 3], [4], [5, 6]]), ... tf.ragged.constant([True, False, True])).to_list() [[1, 2, 3], [5, 6]] RaggedMaskdatanamemaskT) return_dtypeNz*mask.shape.ndims must be known statically.rzmask cannot be scalar.) ragged_rankrow_splits_dtypedtypeaxisFvalidate)r*r')out_type)+r name_scoper"convert_to_tensor_or_ragged_tensorrboolmatch_row_splits_dtypesshapendims ValueError is_ragged RaggedTensor from_tensorr# row_splitsr'nested_row_splitscontrol_dependenciesrassert_splits_matchappendrmap_flat_valuesrcastr reduce_sumlengths_to_splitsvalues boolean_maskfrom_nested_row_splits row_lengthsr rrow_splits_to_segment_idsgatherfrom_row_splitsmin count_nonzeroreshapefrom_row_lengthscumprodrange)rr!r r$ splits_listsplitsint_maskmasked_row_lengths masked_valueslengthsmasked_lengths masked_splits segment_ids segment_maskflattened_masked_lengths mask_shape split_sizedimelt_sizes ]/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/ragged/ragged_array_ops.pyrDrD1sh ~~dL4,7n  ; ;Dv ND  ; ; fkk (D%2%J%J d&'"ltT zz C DD   Q  / 00t$  $ $T *))55 ((!__2264  $"8"89J$:J:J"Kk  # #  ) )+ 6 8 %%d+ ZZ   ! MM$// *-<< t+;=H!0!;!;H1!M  MM+778JK L$$%%d+%T40 &22II 6EJ3 55nnp   &4::+;+;q+@  "g --gtc!#'*H$NN:c?;hFM)66FF}uG>M > ]nn45nns@EU 3CT=/T=> U CU 0BU ;D8U =U U  Uinputc  tj|d||g5tj|d}tj|s t j |||cdddStj|d|jj}|jjdtj|}tjj!t#|||t%|||d cdddS#1swYyxYw) a#Constructs a `RaggedTensor` by tiling a given `RaggedTensor`. The values of `input` are replicated `multiples[i]` times along the `i`th dimension (for each dimension `i`). For every dimension `axis` in `input`, the length of each output element in that dimension is the length of corresponding input element multiplied by `multiples[axis]`. Args: input: A `RaggedTensor`. multiples: A 1-D integer `Tensor`. Length must be the same as the number of dimensions in `input`. name: A name for the operation (optional). Returns: A `RaggedTensor` with the same type, rank, and ragged_rank as `input`. #### Example: >>> rt = tf.ragged.constant([[1, 2], [3]]) >>> tf.tile(rt, [3, 2]).to_list() [[1, 2, 1, 2], [3, 3], [1, 2, 1, 2], [3, 3], [1, 2, 1, 2], [3, 3]] RaggedTiler`rN multiples)r r'r(Fr+)rr0rr1r7r tilerconvert_to_int_tensorr:r'r4assert_has_rankr constant_valuer8rE_tile_ragged_values_tile_ragged_splits)r`rcr const_multipless r_rdrds0 ~~dL5)*<=  < < G E  " "5 ) ^^E9d 3  11 5+;+;+A+ACI OO##A&"00;O  % % < <E9o>E9o> = sAD'BDD c|j}|j}tj|dd}d}t|ddD]Q}||dz }|t j |||dzz|}|||dk7rt j||||}|}St j |j|} t j|dd||dzdgd} t j| | S)a5Builds flat_values tensor for a tiled `RaggedTensor`. Returns a tensor that repeats the values in `rt_input.flat_values` in the appropriate pattern to construct a `RaggedTensor` that tiles `rt_input` as specified by `multiples`. Args: rt_input: The `RaggedTensor` whose values should be repeated. multiples: A 1-D integer `tensor`, indicating how many times each dimension should be repeated. const_multiples: Optional constant value for multiples. Used to skip tiling dimensions where `multiples=1`. Returns: A `Tensor` with the same type and rank as `rt_input.flat_values`. #### Example: >>> rt = tf.ragged.constant([[1, 2], [3]]) >>> _tile_ragged_values(rt, tf.constant([3, 2])).numpy() array([1, 2, 1, 2, 3, 3, 1, 2, 1, 2, 3, 3, 1, 2, 1, 2, 3, 3], dtype=int32) r-Nrr(r)) r#r;rrOr rHr repeat_ranges flat_valuesconcatrd) rt_inputrcrjr# nested_splitsinner_value_ids prev_splitsr*rQragged_tiled_values inner_repeatss r_rhrhs0$$+,,-NN=#4R#89/+KB'd 4!8 $F iq.A A6Jf/$"71"<#11/62;D/CoK""(()=)=O""IbqM9[1_=M3N#O()+- +] ;;c |j}|j}t|Dcgc] }|||i }}t|D]A}t|dz|dz D]*}tj|||||dz |||<,Cg} t|D]} || dd|| ddz } | || dzz} d} t| dz ddD]E}| ||dzdk7r+||| dz | z}t j | |||dz} | ||dzz} Gtj| |dd} | jt j| | Scc}w)aBuilds nested_split tensors for a tiled `RaggedTensor`. Returns a list of split tensors that can be used to construct the `RaggedTensor` that tiles `rt_input` as specified by `multiples`. Args: rt_input: The `RaggedTensor` that is being tiled. multiples: A 1-D integer `tensor`, indicating how many times each dimension should be repeated. const_multiples: Optional constant value for multiples. Used to skip tiling dimensions where `multiples=1`. Returns: A list of 1-D integer `Tensor`s (one for each ragged dimension in `rt_input`). #### Example: >>> rt = tf.ragged.constant([[1, 2], [3]]) >>> _tile_ragged_splits(rt, [3, 2]) [] r(Nr-) r#r;rOr rHrrlrdr>rB)rorcrjr#rpiprojected_splitssrc_axisdst_axis result_splitsr* input_lengthsoutput_lengthsrepeatsdrQs r_riri?s0$$+,,- 6;;5GHq-*+HH $Mh(Q, a8M-6-=-=  !#3H#=hl#K.Mx *MM -K Hd!$'+mD.A#2.FFM#Ytax%88N G 4!8R $"  OAE$:a$?!!$TAX.8$22>63>> rt = tf.ragged.constant([[1, 2], [3]]) >>> print(rt.shape) (2, None) >>> expanded = tf.expand_dims(rt, axis=0) >>> print(expanded.shape, expanded) (1, 2, None) >>> expanded = tf.expand_dims(rt, axis=1) >>> print(expanded.shape, expanded) (2, 1, None) >>> expanded = tf.expand_dims(rt, axis=2) >>> print(expanded.shape, expanded) (2, None, 1) RaggedExpandDimsr`rNr(z rank(input)) ndims_namerF)uniform_row_lengthnrowsr,)rr0rr1r7r expand_dimsr4r5get_positive_axisr8from_uniform_row_lengthrrC with_values)r`r*r r5s r_rrsd ~~d.8P  < < G E  " "5 )  " "5$ / PPKK%%-D5;;3D3Dq3HE  & &tU} MD qy  ' ' ? ? EKKMU@LPP   ' ' ? ? AU[[]U@LPP"   .  U\\4!8!DE%PP(  !6!6u||TAX!NO)PPPs&AF7%A>F7-5F7,AF7<1F77Gc&||}t|||S)N)r`r*r )r)r`r*r r]s r__ragged_expand_dims_v1rs  _ D 5t$ 77ructj|r"tj|j||Stj|||S)aReturns the size of a potentially ragged tensor. The size of a ragged tensor is the size of its inner values. #### Example: >>> tf.size(tf.ragged.constant([[1, 2], [3]])).numpy().item() 3 Args: input: A potentially ragged `Tensor`. out_type: The numeric output type for the operation. name: A name for the operation (optional). Returns: A Tensor of type `out_type`. )r.r )rr7r sizermr`r.r s r_rrs>&U# >>%++hT JJ >>%( >>ruct|||S)Nr)rr`r r.s r__ragged_size_v1rs EH4 88ructj|d|g5}tj|st j ||cdddS|j t j |jzcdddS#1swYyxYw)aReturns the rank of a RaggedTensor. Returns a 0-D `int32` `Tensor` representing the rank of `input`. #### Example: >>> # shape of tensor 't' is [2, None, None] >>> t = tf.ragged.constant([[[1], [2, 2]], [[3, 3, 3], [4, 4, 4, 4]]]) >>> tf.rank(t).numpy().item() 3 Args: input: A `RaggedTensor` name: A name for the operation (optional). Returns: A `Tensor` of type `int32`. RaggedRankN)rr0rr7r rankr#rm)r`r s r_rrsx( ~~dL5'2Ad  " "5 ) ^^E4 (AA   y~~e.?.?@ @ AAAs+B+BB indicesc t|tr=|dk\r8||jkrtd||jfz||jz}t j |d|||||g5t j|d}|jtj|j||||||cdddS#1swYyxYw)z6Applies tf.one_hot along the values of a RaggedTensor.rz8axis (%d) must be greater than indices.ragged_rank (%d). RaggedOneHotrrN) isinstanceintr#r6rr0rr1with_flat_valuesr one_hotrm)rdepthon_value off_valuer*r'r s r_ragged_one_hotr"sctqy w""" "&(;(;!<= >>G  D ~~dNxDAC(>>i!G  # #'--uh 4 ' ( (((s *A B??Czragged.stack_dynamic_partitionsc Btj|d|||g5tj|d}t |tj r|j jnd}tj|d|}tj|d|j}|tj||}tj||j}|jj}| td|jjd |jj|jd||d k(rTtj j!t#j$|gt#j$|g|d cdddS|d k(rt'j(|d }t+j,||}t+j,||}t/j0|dd|dt/j2|dg} tj4| 5tj j!|||d cdddcdddSt |tj s,tj j7||jd }t |tj sCtj j7||jt9|j:|d z }t/j<|j |j d} tj4| g5t?|j@|j@|cdddcdddS#1swYnxYw#1swYnxYwdddy#1swYyxYw)aStacks dynamic partitions of a Tensor or RaggedTensor. Returns a RaggedTensor `output` with `num_partitions` rows, where the row `output[i]` is formed by stacking all slices `data[j1...jN]` such that `partitions[j1...jN] = i`. Slices of `data` are stacked in row-major order. If `num_partitions` is an `int` (not a `Tensor`), then this is equivalent to `tf.ragged.stack(tf.dynamic_partition(data, partitions, num_partitions))`. #### Example: >>> data = ['a', 'b', 'c', 'd', 'e'] >>> partitions = [ 3, 0, 2, 2, 3] >>> num_partitions = 5 >>> tf.ragged.stack_dynamic_partitions(data, partitions, num_partitions) Args: data: A `Tensor` or `RaggedTensor` containing the values to stack. partitions: An `int32` or `int64` `Tensor` or `RaggedTensor` specifying the partition that each slice of `data` should be added to. `partitions.shape` must be a prefix of `data.shape`. Values must be greater than or equal to zero, and less than `num_partitions`. `partitions` is not required to be sorted. num_partitions: An `int32` or `int64` scalar specifying the number of partitions to output. This determines the number of rows in `output`. name: A name prefix for the returned tensor (optional). Returns: A `RaggedTensor` containing the stacked partitions. The returned tensor has the same dtype as `data`, and its shape is `[num_partitions, (D)] + data.shape[partitions.rank:]`, where `(D)` is a ragged dimension whose length is the number of data slices stacked for each `partition`. SegmentStackrrN partitions)r preferred_dtypenum_partitionsz partitions must have known rank.rF)rC value_rowidsrr,r(T)stabler-z+partitions must be less than num_partitionsmessagez partitions must be non-negative.)rr,)r$r#z3data and partitions have incompatible ragged shapes)!rr0rr1rr8r:r'convert_to_tensorrr@r4r5r6rfassert_is_compatible_withfrom_value_rowidsr stackrargsortr rHr assert_lessassert_non_negativer<r9maxr# assert_equalstack_dynamic_partitionsrC) rrrr r$partitions_rank permutationrrCcheckschecks r_rr?seN ~~dNT:~,NO@8  ; ;Dv ND dM66 7 =AAA7GIJ**-z?O?OQN#==-=>j]]>:3C3CDN!&&,,O 9 ::((+..tzz:J?/KL! ' ' 9 9 &&v.&,,j\: :1@8@8< A $$Z=k%%j+>lk2f   23C E  ' '"D F f  # #F +H));; L<HHHY@8@8dm88 9))55 :#3#36D  M$>$> ?"//;; '--D,,o.AB<D $$ //   GIe  # #UG ,8' Z5F5F(6888}@8@8XHH$88}@8@8@8sJE1NBN%#M4 NC%N!N! N4M= 9NN NNrc d}tj|d||g5t|tjr"t j |}|>t|t|ttfrtd|Ds t|tj|d}t|Dcgc]4\}}tj||j j"d|zd6}}}t%dg|rt'|d znd z}|D]}t%ddd ||<|t|cdddScc}}w#1swYyxYw) aReverses a RaggedTensor along the specified axes. #### Example: >>> data = tf.ragged.constant([ ... [[1, 2], [3, 4]], [[5, 6]], [[7, 8], [9, 10], [11, 12]]]) >>> tf.reverse(data, axis=[0, 2]) Args: tensor: A 'RaggedTensor' to reverse. axis: A list or tuple of 'int' or a constant 1D 'tf.Tensor'. The indices of the axes to reverse. name: A name prefix for the returned tensor (optional). Returns: A 'RaggedTensor'. zW`axis` must be a list of int or a constant tensorwhen reversing axes in a ragged tensorReverseNc3<K|]}t|tywN)rr).0r]s r_ zreverse..s73*S#&7srrzaxis[%d]z rank(tensor)r(rr-)rr0r tensor_libTensorr rg TypeErrorlisttupleallrr1 enumerater rr4rslicer)rr*r type_error_msgrwr]slicess r_reversersB(=. ~~dI~6!$ ))*  ' ' -d ''e}-7$77 n %%  = =XF o  As ##C):):JN$2 4 D Dk]tc$i!m ;F*$b)fSk* %- 5!! !!sBE19D:*AE:EE z ragged.crossct|d|S)aXGenerates feature cross from a list of tensors. The input tensors must have `rank=2`, and must all have the same number of rows. The result is a `RaggedTensor` with the same number of rows as the inputs, where `result[row]` contains a list of all combinations of values formed by taking a single value from each input's corresponding row (`inputs[i][row]`). Values are combined by joining their strings with '_X_'. E.g.: >>> tf.ragged.cross([tf.ragged.constant([['a'], ['b', 'c']]), ... tf.ragged.constant([['d'], ['e']]), ... tf.ragged.constant([['f'], ['g']])]) Args: inputs: A list of `RaggedTensor` or `Tensor` or `SparseTensor`. name: Optional name for the op. Returns: A 2D `RaggedTensor` of type `string`. F)inputs hashed_outputr _cross_internal)rr s r_crossrs0 e$ GGruzragged.cross_hashedc"t|d|||S)aGenerates hashed feature cross from a list of tensors. The input tensors must have `rank=2`, and must all have the same number of rows. The result is a `RaggedTensor` with the same number of rows as the inputs, where `result[row]` contains a list of all combinations of values formed by taking a single value from each input's corresponding row (`inputs[i][row]`). Values are combined by hashing together their fingerprints. E.g.: >>> tf.ragged.cross_hashed([tf.ragged.constant([['a'], ['b', 'c']]), ... tf.ragged.constant([['d'], ['e']]), ... tf.ragged.constant([['f'], ['g']])], ... num_buckets=100) Args: inputs: A list of `RaggedTensor` or `Tensor` or `SparseTensor`. num_buckets: A non-negative `int` that used to bucket the hashed values. If `num_buckets != 0`, then `output = hashed_value % num_buckets`. hash_key: Integer hash_key that will be used by the `FingerprintCat64` function. If not given, a default key is used. name: Optional name for the op. Returns: A 2D `RaggedTensor` of type `int64`. T)rr num_bucketshash_keyr r)rrrr s r_ cross_hashedrs :     rul/{ct|ttfs td|t}g}g}g}g}t j |d|5t|D]z\} } tj| r tjj| } ntj| } | jjr%t!j"| t$j&} n7| jt$j(k7rt+d| | jfzt| tj,r>| j.dk7r t+d|j1| |j1dt| tjr$|j1| |j1dY|j1| |j1d }|rt$j&nt$j(} |r#t3d |Drt$j4} nt$j&} |d kDr|d z}t7j8|D cgc]} | j:c} |D cgc]} | j<c} |Dcgc]}|j>c}|Dcgc]}|j:c}|Dcgc]}|j@c}|d jC||||| jD| jD| \}}tj,jG||dcdddScc} wcc} wcc}wcc}wcc}w#1swYyxYw)z@Generates feature cross from a list of ragged and dense tensors.zInputs must be a listN RaggedCrossz#Unexpected dtype for inputs[%d]: %sr(z0tf.ragged.cross only supports inputs with rank=2RSDc3jK|]+}|jjtjk(-ywr)r:r'rint32)rts r_rz"_cross_internal..Os*C/0 fll*Cs13ll) ragged_valuesragged_row_splitssparse_indices sparse_values sparse_shape dense_inputs input_orderrrrout_values_typeout_row_splits_typer Fr+)$rrrr_DEFAULT_CROSS_HASH_KEYrr0rr is_sparse SparseTensor from_valuerr1r' is_integerrr@rint64stringr6r8r#r>rrr ragged_crossrCr:r dense_shapejoinas_datatype_enumrI)rrrrr ragged_inputs sparse_inputsrrrwrrrrtst values_out splits_outs r_rr(s FUDM * + ,, &H--,+ ~~dM6220&! 1   #  & & 1 1! 4  < !QWWMNN A}11 2 ==A MN NQ3 a33 4Q3A3' *'4fllOC4ACC"LL"LL%%h1>>+89Rryy93@AR2==A-:;r ;+89Rryy9/<=bnn=!GGK(#'88/@@  J   % % 5 5J 6 0c2020F:A;9=O2020sP G>L8L L8 L$ 3L89L) L8L.%L8+L3>AL8L88Mctj|d|g5t|tjst dt |tj||j}tj|j|j|j|\}}}}tjj||d|fcdddS#1swYyxYw)a*Fills empty rows in the input `RaggedTensor` with rank 2 with a default value. This op adds entries with the specified `default_value` for any row in the input that does not already have a value. The op also returns an indicator vector such that empty_row_indicator[i] = True iff row i was an empty row. Args: ragged_input: A `RaggedTensor` with rank 2. default_value: The value to fill for empty rows, with the same type as `ragged_input.` name: A name prefix for the returned tensors (optional) Returns: ragged_ordered_output: A `RaggedTensor`with all empty rows filled in with `default_value`. empty_row_indicator: A bool vector indicating whether each input row was empty. Raises: TypeError: If `ragged_input` is not a `RaggedTensor`. RaggedFillEmptyRowsz3ragged_input must be RaggedTensor, got r&)rrCr default_valueF)rCrr,N)rr0rrr8rtyperr'rragged_fill_empty_rowsrrCrr) ragged_inputrr output_value_rowids output_valuesempty_row_indicatorunused_reverse_index_maps r_fill_empty_rowsrms6 ~~d1L>B lM$>$> ?  < ! # ))\//M 33!..0""  "#     ""44 , 5   )s B:CC&rc`|jd}tj||\}}d|d|gS)z"Gradients for RaggedFillEmptyRows.r/)reverse_index_map grad_valuesN)outputsrragged_fill_empty_rows_grad)opunused_grad_output_indicesoutput_grad_valuesunused_grad_empty_row_indicatorunused_grad_reverse_index_maprd_valuesd_default_values r__ragged_fill_empty_rows_gradr s>jjm2NN)7I(O $ 00rurrct|tr|dkr tdt||||}t |Dcgc]}|| c}Scc}w)z8RaggedTensor dispatch override for tf.dynamic_partition.rz-num_partitions must be a non-negative integer)rrrrrO)rrrr resultrws r_dynamic_partitionrsN NC (NQ,> C DD #D*nd K&">2 3&) 33 3s A valuec Ntj|d5tj|d}t |t r|dk(r |gcdddSt j|dtjj|}tj||j} ||}t |t rC|}|dkrtd |d tj ||}tj"||} nd}tj$|} | j&j(J| j&j(dk7rt+d |d t-j.| j&d }||td|d|d |}n|||k7rtd|d|d tj0d gtj2| gd } g} | j5t j6|d| j5t j8|tj&| d d| j5t j8tj:|| j<| ddt?j@| | } g} tCdg|dzz} tE|D]7}tC| || |dz| d<| j5|tG| 9| cdddS#t$rtd|d |d wxYw#1swYyxYw)a Splits a RaggedTensor `value` into a list of sub RaggedTensors. If `num_or_size_splits` is an `int`, then it splits `value` along the dimension `axis` into `num_or_size_splits` smaller RaggedTensors. This requires that `value.shape[axis]` is divisible by `num_or_size_splits`. If `num_or_size_splits` is a 1-D Tensor (or list), then `value` is split into `len(num_or_size_splits)` elements. The shape of the `i`-th element has the same size as the `value` except along dimension `axis` where the size is `num_or_size_splits[i]`. Splits along a ragged dimension is not allowed. For example: >>> rt = tf.RaggedTensor.from_row_lengths( ... np.arange(6 * 3).reshape(6, 3), row_lengths=[1, 2, 2, 1]) >>> rt.shape TensorShape([4, None, 3]) >>> >>> rt1, rt2 = tf.split(rt, 2) # uniform splits >>> rt1.shape TensorShape([2, None, 3]) >>> rt2.shape TensorShape([2, None, 3]) >>> >>> rt3, rt4, rt5 = tf.split(rt, [1, 2, 1]) # ragged splits >>> rt3.shape TensorShape([1, None, 3]) >>> rt4.shape TensorShape([2, None, 3]) >>> rt5.shape TensorShape([1, None, 3]) >>> >>> rt6, rt7 = tf.split(rt, [1, 2], axis=2) # splits along axis 2 >>> rt6.shape TensorShape([4, None, 1]) >>> rt7.shape TensorShape([4, None, 2]) Args: value: The `RaggedTensor` to split. num_or_size_splits: Either an `int` indicating the number of splits along `axis` or a 1-D integer `Tensor` or Python list containing the sizes of each output tensor along `axis`. If a Python int, then it must evenly divide `value.shape[axis]`; otherwise the sum of sizes along the split axis must match that of the `value`. axis: An `int` or scalar `int32` `Tensor`. The dimension along which to split. Must be in the range `[-rank(value), rank(value))`. Defaults to 0. num: An `int` used to specify the number of outputs when `num_or_size_splits` is a 1-D list or `Tensor` and its length is statically unknown, e.g., specifying `tf.TensorSepc(None)` with the `input_signature` argument of `tf.function` (optional). name: A name for the operation (optional). Returns: if `num_or_size_splits` is an `int` returns a list of `num_or_size_splits` `RaggedTensor` objects; if `num_or_size_splits` is a 1-D Tensor returns `num_or_size_splits.get_shape[0]` `RaggedTensor` objects resulting from splitting `value`. Raises: ValueError: If the dimension `axis` of `value` is a ragged dimension. ValueError: If `num` is unspecified and cannot be inferred. ValueError: If `num` is specified but doesn't match the length of `num_or_size_splits`. ValueError: If `num_or_size_splits` is an `int` and less than 1. TypeError: If `num_or_size_splits` is not an `int` or 1-D list or 1-D `Tensor`. InvalidArgumentError: If the `axis` of `value` cannot be exactly splitted by `num_or_size_splits`. InvalidArgumentError: If `num_or_size_splits` is contains negative integers. InvalidArgumentError: If `num_or_size_splits`'s static shape is unknown and its dynamic shape is inconsistent `num`. InvalidArgumentError: If `num_or_size_splits`'s static rank is unknown and `axis` is a negative integer. RaggedSplitrrr(NzJ`num_or_size_splits` must be an `int` or 1-D list or `Tensor` of integers.rz8Cannot split a ragged dimension. Got `value` with shape z and `axis` .z<`num_or_size_splits` must be >=1 if it is an `int`.Received zH`num_or_size_splits` must be an `int` or 1-D list or `Tensor`. Received rzp`num` must be specified as an `int` when the size of `num_or_size_split` is statically unknown. Received `num`: z and `num_or_size_split`: zF`num` does not match the size of `num_or_size_split`. Received `num`: z" and size of `num_or_size_split`: r)z*`num_or_size_splits` must be non-negative.z8`num` is inconsistent with `num_or_size_split.shape[0]`.r-zXCannot exactly split the `axis` dimension of `value` with the given `num_or_size_split`.)$rr0rr1rrr assert_integer_v2rDynamicRaggedShaper9r rrr6rfloordivrepeatrr4r5rr dimension_valuerncumsumr>assert_non_negative_v2assert_equal_v2r@r'rwith_dependenciesrrOr)rnum_or_size_splitsr*numr value_shapedim_size num_splits split_length split_lengthsrQr splited_rtsrrws r_splitr$sh ~~dM*H  < < G E$c*/AQ/FW HH)+'99EEeLK  & &t[-=-= >DBT"h$c*%j a%%7$8;< <&&x?m    " " .    $ $ )33E2FaIJ J!11-2E2Ea2HI   ;77:e<33E2FaIJ J ?sj0CCF%H;;E,aIJ J  sHOOM$BC! LF F MM(( @ BC MM!!  OOM *1 -N PQ  MM!! MM(FLL 1 2J; =>  / / ?FKDk]dQh 'F : /F1q5M2fRjuV}-./ QHH B  +}LaA BBBHHs+/LAL'K<,IL<LLL$r4returnctj|d}t|tjr |j}t|t j rLtj||j}tjj||jdStj|d}tj||S)z#Reshapes a tensor or ragged tensor.rrFr+r4)rr1rr8rCrrr rL inner_shape_from_nested_row_partitionsrow_partitionsrr)rr4rms r_ragged_reshaper*os  ; ; 8 & 223 ]]F+>>?##FE,=,=>K  % % A A  B   ! !%g 6E   VU ++ruc.tj||S)aBroadcasts a potentially ragged tensor to a ragged shape. Tiles `input` as necessary to match the given shape. Behavior is undefined if `input` is not broadcast-compatible with `shape`. Args: input: The potentially ragged tensor to broadcast. shape: A `DynamicRaggedShape` Returns: A potentially ragged tensor whose values are taken from `input`, and whose shape matches `shape`. )r broadcast_to)r`r4s r_r,r,s&  * *5% 88rur ctj|d|g5tjj ||cdddS#1swYyxYw)zReturns the shape of a RaggedTensor. Args: input: A `RaggedTensor` name: A name for the operation (optional). out_type: dtype used to encode the shape. Returns: A `tf.experimental.DynamicRaggedShape` RaggedShapeN)rr0rrr9rs r_ ragged_shaper/sE ~~dME73P  2 2 > >uh OPPPs AA shape_xshape_yct|tjstjg|}t|tjstjg|}tj||S)aReturns the shape formed by broadcasting two shapes to be compatible. 1. If shape_x and shape_y both have row_partitions, then fail if their dtypes don't match. 2. If neither has row_partitions and they have different dtypes, go with int64. 3. If one has row_partitions, go with that dtype. Args: shape_x: A `DynamicRaggedShape` shape_y: A `DynamicRaggedShape` Returns: A `DynamicRaggedShape`. Raises: ValueError: If `shape_x` and `shape_y` are not broadcast-compatible. )rrrbroadcast_dynamic_shape)r0r1s r_r3r3s], G1DD E"55b'BG G1DD E"55b'BG  5 5gw GGruc||jstd|tj|j|||}|j |SzReturns ones shaped like x.0RaggedTensor only allows replicated layout. got )r'r layout)is_fully_replicatedr6r onesr'_add_row_partitionsr4r'r r7rms r_r9r9s^  : : <  :6(C  u4+  " "; //ruc||jstd|tj|j|||}|j |Sr5)r8r6r zerosr'r:r;s r_r=r=s^  : : <  :6(C  u4+  " "; //rudimsc||jstd|tj|j|||}|j |S)z=Creates a tensor with shape `dims` and fills it with `value`.r6)r r7)r8r6r fillr'r:)r>rr r7rms r_r@r@s^  : : <  :6(C  D+  ! !+ ..ructj|}tj|d|g5t j |d}|j j|jkrO|jjjdkr,td|jjj|jtj|j|cdddS#1swYyxYw)z.RaggedTensor dispatch override for tf.bitcast.Bitcastr`rr%zb`input.flat_values` is required to have rank >= 2 when input.dtype.size < type.size. Actual rank: N)ras_dtyperr0rr1r'rrmr4rr6rr bitcast)r`rr s r_rDrDs  $ ~~dIw/N  < < G E 499$):):)@)@)E)E)I E++116679 ::  ! !)"3"3E4E4Et"L MNNNs B8C00C9r)NNN)NNNNN)rNN)FrNN)NN)Q__doc__typingrrtensorflow.python.frameworkrrrrrr r tensorflow.python.opsr r r rrrrrtensorflow.python.ops.raggedrrrrrrtensorflow.python.typesr core_typestensorflow.python.utilr tensorflow.python.util.tf_exportradd_dispatch_supportrDdispatch_for_apirdRaggedrhriexpand_dims_v2rrsize_v2rrrrrrrrrrrrrRegisterGradientr r RaggedOrDenser$rLDenseOrRaggedShaper8rr*r,rr4strr/r3r9float32r=r@ TensorLikerDrur_rZs*.+5<43+1+2/6**=>86476+6 ! `"`L9>>*' $$'+'T8>*  \\9   9+99>>*A $$A+A:9,,-!! (M00(.(8 ,- e8.e8V9,,-0!M((0!.0!p > HH2 !  " F'#( !! B0J6r+,1-1*=::; 4M774"/"="=4<49??+ [%%[,[F9,,-,  ' ',  2 2, = % %z'8'8 89,.,*91129  & &9  2 29 = % %z'8'8 89939.9??+ \\P   P 3-P3EEP,P$9<<=H ! 4 4H ! 4 4H,,H>H89>>* ..  0  2 20   0+0"9??+ ..  0  2 20   0,0"9>>*  /  1 1/  / 3-/   /+/(9,,-  N  & & N -- N. Nru