AVhFdZddlZddlmZmZmZmZmZmZddl Z ddl m Z ddl m Z ddl mZddl mZddl mZdd l mZdd l mZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#ddl$m%Z%GddejLZ'e%dGddejPZ)de)de)de)fdZ*d e)fd!Z+d"e)d#e)fd$Z,d%Z-e#j\ej^ej^d&Z0e#jbej^ej^d'Z2d(Z3d)Z4d*eed+ee jjdee jjfd,Z6Gd-d.ejnZ8Gd/d0e8Z9Gd1d2Z:d3Z;d4Zd7Z?d8e8d9edee8effd:Z@d8e8d;e8d9edZBd8e8d;e8d9edrIrOrr RaggedTensor tensor_libTensorrUr\ TensorSpecr^rJr=rr.s5%4%N)-)2K)VF.F * %*}99:;L;LLM * %+ % ] + +Z-B-B BC %rJrzexperimental.DynamicRaggedShapec xeZdZUdZeedfed<ejed<e jed<e Z dZ d4de ed ejd eej$d ed df d Zedej,fde ee eeffdZed5dZed5dZed5dZedZedZedZ dZ!d6dZ"dZ#de jfdZ$dZ%dZ&dZ'dZ(dZ)d Z*ed!Z+ed"Z,ed#Z-d$Z.d%Z/d&Z0d'Z1d(ed)eddfd*Z2d+Z3d7d,Z4 d8d-Z5d.Z6d/Z7d0Z8d9d1Z9Gd2d3Z:y):r0aThe shape of a ragged or dense tensor. Ragged shapes are encoded using two fields: * `inner_shape`: An integer vector giving the shape of a dense tensor. * `row_partitions`: A list of `RowPartition` objects, describing how that flat shape should be partitioned to add ragged axes. If a DynamicRaggedShape is the shape of a RaggedTensor rt, then: 1. row_partitions = rt._nested_row_partitions (and thus len(row_partitions) > 0) 2. inner_shape is the shape of rt.flat_values If a DynamicRaggedShape is the shape of a dense tensor t, then: 1. row_partitions = [] 2. inner_shape is the shape of t. Examples: The following table gives a few examples (where `RP(lengths)` is short for `RowPartition.from_lengths(lengths)`): Row Partitions | Inner Shape | Example Tensor --------------------------- | ------------ | ---------------------------- [] | [2, 3] | `[[1, 2, 3], [4, 5, 6]]` [RP([2, 0, 3])] | [5] | `[[1, 2], [], [3, 4, 5]]` [RP([2, 1])] | [3, 2] | `[[[1, 2], [3, 4]], [[5, 6]]]` [RP([2, 1]), RP([2, 1, 2])] | [5] | `[[[1, 2], [3]], [[4, 5]]]` .r, _inner_shaper/ztf.DynamicRaggedShapeNr$ inner_shaper&validater%ct|tstdt|z|D],}t|trtdt|zdzt ||}t ||}t|tjr/|jtjk(r|tj}t tj|}t|Dcgc]}|j|c}}||_t!j"||d|_|j$j|k7r%t'j(|j$||_g}|jrt+|jD]\} }| dkDs |j| dz } d | dz d | } |j,} | j.} | | | | k7r t1| V|sY|j3t5j6| j9|j;| |j$j<j?dtAjB|j$|_"| |jDjG||_"|r|d }|j.} tIjJ|jDd}| || |k7rOt1d |rB|j3t5j6|j9|j$dd |rVtMjN||j$d|_|jDcgc]}|jQ|c}|_yycc}wcc}w)aCore constructor for a DynamicRaggedShape. Create a DynamicRaggedShape. This can be used to construct a DynamicRaggedShape representing a ragged or dense shape. If row_partitions is an empty list, then this is equivalent to a dense shape. If row_partitions is specified, then the num_row_partitions will be equal to len(row_partitions). There are several checks made. Specifically: 1. Consecutive row_partitions must have consistent nvals and nrows. 2. The last row_partitions must have nvals equal to the first element of inner_shape. The inner_shape is converted to a tensor. All row_partitions and the inner_shape are converted to the same dtype (int64 or int32). Args: row_partitions: the row_partitions of the shape. inner_shape: if len(row_partitions) > 0, the shape of the flat_values. Otherwise, the shape of the tensor. dtype: tf.int64, tf.int32, or None representing the preferred dtype. validate: if true, dynamic validation is applied to the shape. static_inner_shape: if len(row_partitions) > 0, the static shape of the flat_values. Otherwise, the static shape of the tensor. Should be convertible to a TensorShape. z@row_partitions should be a list of row partitions. Instead, got zrow_partitions contains z which is not a RowPartitionNinner_dim_sizes) dtype_hintnamerr@z9RowPartitions in DynamicRaggedShape do not align between z and messagerWz.Last row partition does not match inner_shape.inner_shape_validated)ro)) isinstancer TypeErrorstrr_find_dtype_iterable _find_dtypenpndarrayr&int32r int64tuple with_dtyper,r convert_to_tensorrircast enumerate static_nrows static_nvals ValueErrorrDr assert_equalrCrBrXassert_has_rankrconstant_value_as_shaper/ merge_withrdimension_valuerwith_dependencies_with_dependencies)r6r$rjr&rkr%xr9checksaxisprevious_row_partitionmsgrrlast_row_partitionstatic_inner_shape_nvalss r=__init__zDynamicRaggedShape.__init__sPB nh /  L n   8 < (2SV;678 88 ! 7E  U +E; +RXX%%-lle  e ,E>JRBMM%0JKN)D--,=?D %'"--(9(95Ad F  4 45N($ !8#'#7#7q#A  1H:U4&2#,/<<,&\-E|+sO#  MM&&*002BHHJM NN" ++A.*BB  D%!%!9!9!D!D "d)"-'44l!-!=!=  " "1 %"'  !&>&J 3 3KL L   " ""((*!!!$H J K *<< $##*ACd372F2F,."   'dcKhs M0M5lengthscTt|ts td|D]}t|rtd||R|Dcgc]}t|t }}t |r't ||dddjdz dz }nd}t|ts td|s|dkDr td tgg| S|t |ks td |dkDr.t|d|dz\}}|g||dzdz}t||| Stg|| Scc}w) a Creates a shape with the given lengths and num_row_partitions. The lengths can either be a nonnegative int or a list of nonnegative ints. If num_row_partitions is None, then the minimal num_row_partitions is used. For example, [2, (3, 2)] is the shape of [[0, 0, 0], [0, 0]], and [2, 2] is the shape of [[0, 0], [0, 0]] This chooses the minimal num_row_partitions required (including zero). The following table gives a few examples (where `RP(lengths)` is short for `RowPartition.from_lengths(lengths)`): For example: from_lengths | row_partitions | inner_shape ---------------------- | --------------------------| ------------- [] | [] | [] [2, (3, 2)] | [RP([3, 2])] | [5] [2, 2] | [] | [2, 2] [2, (3, 2), 7] | [RP([3, 2])] | [5, 7] [2, (2, 2), 3] | [RP([2, 2])] | [4, 3] [2, 2, 3] | [] | [2, 2, 3] [2, (2, 1), (2, 0, 3)] | [RP(2, 1), RP([2, 0, 3])] | [5] If we want the row partitions to end with uniform row partitions, then we can set num_row_partitions. For example, below URP(3, 12) is RowPartition.from_uniform_row_length(3, 12) from_lengths | num_row_partitions | row_partitions | inner_shape ---------------| -------------------|--------------------------|------------ [2, (3, 2), 2] | 2 | [RP([3, 2]), URP(2, 10)] | [10] [2, 2] | 1 | [URP(2, 4)] | [4] [2, 2, 3] | 0 | [] | [2, 2, 3] [2, 2, 3] | 1 | [URP(2, 4)] | [4, 3] [2, 2, 3] | 2 | [URP(2, 4), URP(3, 12)] | [12] Representing the shapes from init(): from_lengths | Tensor Example ------------------------ | ------------------------------ `[2, 3]` | `[[1, 2, 3], [4, 5, 6]]` `[3, (2, 0, 3)]` | `[[1, 2], [], [3, 4, 5]]` `[2, (2, 1), 2]` | `[[[1, 2], [3, 4]], [[5, 6]]]` `[2, (2, 1), (2, 1, 2)]` | `[[[1, 2], [3]], [[4, 5]]]` Args: lengths: the lengths of sublists along each axis. num_row_partitions: the num_row_partitions of the result or None indicating the minimum number of row_partitions. dtype: the dtype of the shape (tf.int32 or tf.int64). Returns: a new DynamicRaggedShape zlengths should be a listz;element of lengths should be int or tuple of ints: instead NrWTr@rz+num_row_partitions should be an int or Nonez(num_row_partitions==0 for a scalar shaper'zMnum_row_partitions should be less than `len(lengths)` if shape is not scalar.) rslistr_is_int_or_tuple_of_intsintanylenindexr0)_to_row_partitions_and_nvals_from_lengths) clsrr*r&ris_listr$rCrjs r= from_lengthszDynamicRaggedShape.from_lengths4sd@ gt $ 1 22  %a (    !189AZ3''9g9 W \GBFFO,A,A$,GG!K (# . D EE  a CDD Be 44 G , 1 22A I )%) *!,~uGg&81&<&=>>k  5 II G5 993:sD%c`|s td|djg}t|||S)zCreate a shape from row_partitions. Args: row_partitions: a nonempty list of RowPartition objects. dtype: the dtype to use, or None to use the row_partitions dtype. Returns: a DynamicRaggedShape with inner_rank==1. zrow_partitions cannot be emptyrWr')rrCr0)rr$r&rjs r=from_row_partitionsz&DynamicRaggedShape.from_row_partitionss8  7 88!"%++-.K nk GGrJctg||S)z?Create a shape from inner_shape, where num_row_partitions == 0.r')r0)rrjr&s r=_from_inner_shapez$DynamicRaggedShape._from_inner_shapes b+U ;;rJctj|r!t|jt ||Stj t j||S)z:Constructs a ragged shape for a potentially ragged tensor.r')r is_raggedr0_nested_row_partitions_flat_values_shaperrrX)rtr&s r=rMzDynamicRaggedShape.from_tensors\q!  " "$6q$9HH 1 1 //! E2++rJc|jS)z The row_partitions of the shape.)r,r6s r=r$z!DynamicRaggedShape.row_partitionss   rJc,t|jS)z*The number of row_partitions of the shape.rr,rs r=r*z%DynamicRaggedShape.num_row_partitionss t## $$rJc.|jjS)z6The dtype of the shape -- one of tf.int32 or tf.int64.rir&rs r=r&zDynamicRaggedShape.dtype    " ""rJcz|jjdgS|jj}|r|ddS|S)zAReturns the lengths of the inner shape (if rank known), or [...].N.r@)r/r[as_list)r6truncate_firstrFs r=_static_inner_shape_as_listz.DynamicRaggedShape._static_inner_shape_as_listsC $$,Ul  % % - - /F ABZ MrJcN|jdk(r|jdS|jdj}t |t j r |j}|g}|jD]}|jr|j|j/|r`tj|j}||jdh|jt|j|jd||jdzS)aReturns a list of statically known axis lengths. This represents what values are known. For each row partition, it presents either the uniform row length (if statically known), the list of row lengths, or none if it is not statically known. For the inner shape, if the rank is known, then each dimension is reported if known, and None otherwise. If the rank of the inner shape is not known, then the returned list ends with an ellipsis. Args: ragged_lengths: If false, returns None for all ragged dimensions. Returns: A Sequence[Union[Sequence[int],int, None]] of lengths, with a possible Ellipsis at the end. rFNT)r*rr$rrsr DimensionrS is_uniformrDstatic_uniform_row_lengthrconstant_value row_lengthsr|tolist)r6ragged_lengths first_dimrp_dimsr9 const_valss r=static_lengthsz!DynamicRaggedShape.static_lengthss" !#  - -e 44##A&33I)\334//ikG!!  r334  //0@A   ..  ..z0023 4t  T55d; ;;rJcZt|j}d|d|jdS)Nz)_list_with_ellipsis_to_strrr*r6rs r=__repr__zDynamicRaggedShape.__repr__s,()<)<)>?Gd-- /0rJr!c|jd}|stjdS|dtk(rtjdStj|S)z2Returns a TensorShape representation of the shape.F)rrgrWN)rr TensorShapeEllipsisrs r=r]z#DynamicRaggedShape._to_tensor_shapesW!!!7G   % %b ))r{h  % %d ++  # #G ,,rJc||krtjgS|dk(r||jkrh|dk(r1tj|jdj gS|jd|dz }|dj g}t||S|j 7||jz }|jd|}t|j|ddS|j |kr|S||jz }|jd|}t|j|tjdg|zdS|j ||j kr|jd|}n|}|jD]}|jrtd|j tdtj|jdj|dS) aHReturns a shape self[start:stop]. If start == 0, then this truncates dimensions after stop. If start != 0, then this will return a shape with num_row_partitions == 0. See __getitem__. Args: start: the first dimension. 0 <= start <= rank stop: the last dimension (exclusive). 0 <= stop <= rank rr@NrWF)r$rjr%rkz'All relevant dimensions must be uniformz7__getitem__[start:stop] where start > 0 not implemented)r0rr*r$rBrCr[rjrr _slice_shaperrNotImplementedError_with_num_row_partitions)r6startstopnew_row_partitionsnew_inner_shapenew_inner_rankpartialrs r=rzDynamicRaggedShape._slice_shapes u}  1 1" 55 ! (( ( 19#55""1%++-.0 0!00$(;-b1779:!"4oFF 99 $"9"99. ,,_n=/#!00)!%   YY$ + 7 77**?N;!..'+778F9G H    dTYY.##At,%%F!||~DE EF  " EG G 1 1  * *1 - 9 9%& ACCrJcj|j}t|ts td|jdk(s||jdzkDr8| t d||k\r&t dt|zdzt|z|dkrt dt|z|j|st dt|zd z|dk(rh|jdkDrY|jdj}|!tj||j S|jdjS|jdk(rTtj |j"|}|!tj||j S|j$|S||jkDrntj |j"||jz }|!tj||j S|j$||jz S|j|dz j'S) zEReturn a dimension, if the dimension is not ragged (see __getitem__).zindex should be an intrr@7Rank must be known to use __getitem__ on a large index.zIndex is too big: z>=zIndex must be non-negative: zIndex z is not uniformr')r[rsrrtr*r IndexErrorrurr$rr constantr&rBrrr/rjr))r6rr[r static_results r=r4zDynamicRaggedShape._dimensionAs 99D eS ! . // 1$0G0G!0K(K  EG G $-E :TACIMNN qy 5E B CC __U # x#e*,/@@ AA !//!3((+88l  !##L CC   # ) ) ++ A %"22  " "5 )+m  "##MDD   e $$ (( ("22  " "54+B+B#B CEm  "##MDD   ed&=&== >>   + > > @@rJc|j}t|trw|j|jdk7r t d|j }|j }|d}t|||j}t||}|j||St|tr7|dkr!| td|j||zS|j|Std)aReturns a dimension or a slice of the shape. Ragged shapes can have ragged dimensions that depend upon other dimensions. Therefore, if you ask for a dimension that is ragged, this function returns a ValueError. For similar reasons, if a slice is selected that includes a ragged dimension without including the zero dimension, then this fails. Any slice that does not start at zero will return a shape with num_row_partitions == 0. Args: index: the index: can be an int or a slice. Raises: IndexError: if the index is not in range. ValueError: if the rank is unknown, or a ragged rank is requested incorrectly. r@zCannot stride through a shaperzrJc>|j}|y|j|zS)z;The number of dimensions in this shape, or None if unknown.Nr2r*r6r2s r=r[zDynamicRaggedShape.ranks'J   $ $z 11rJc|jS)zZThe inner dimension sizes for this shape. Returns: A 1-D integer `Tensor`. )rirs r=rjzDynamicRaggedShape.inner_shapes   rJcTtj|jjS)zThe rank of inner_shape.)rrr/r[rs r=r2zDynamicRaggedShape.inner_ranks!  ' '(@(@(E(E FFrJc|dk(r td|jdk(r td||jk(r |jS||jkr|jj r!t |j|j |S|j| }|dk(rtj|dS|jd|z d}tjtj|d|gdS||jkDsJ||jz }t|j| dDcgc]}|j c}r td|j| }||jz }|g|j| dDcgc]}|jc}z}tjtj ||jddgdScc}wcc}w)a5Get an alternative inner shape with higher or lower rank. For the rank of the inner shape to be be higher, the last few ragged dimensions must have uniform_row_length. Args: new_inner_rank: the new rank of the inner_shape Returns: A new inner_shape of rank new_inner_rank. rznew_inner_rank cannot be zerozold inner_rank cannot be zeror@Nrz1Cannot get an inner shape over a ragged dimension)rr2rjr/is_fully_defined"_alt_inner_shape_from_tensor_shaper&rr expand_dimsconcatrr$rr)rstack)r6rfirst_dimensionremaining_dimensionsnew_dimensionsrnew_dimss r=_alt_inner_shapez#DynamicRaggedShape._alt_inner_shapes 6 77 A  6 77 4?? *    $// ) ! ! 2 2 41$2J2J26**nN N55~oFo 1 $$_a88!--a..@.AB     ! 46J Kdoo -- -%7n '+':':N?;K'L M!q||~  M OLMM55~oFo%7n!"*.*=*=~o>N*O&%&!   &h     *D,<,4  Y 'EvErJc|j}| td|dkr||k(r|Std||z }|j|S)atReturns the same shape but a different inner_rank. All dimensions that are to be represented in the inner_shape must be dense. See inner_rank. Args: inner_rank: the new inner_rank of the shape. Returns: the same shape but a different inner_rank Raises: ValueError if the new dense rank is invalid, or the old rank is unknown. z'Rank must be known to adjust inner_rankz$Cannot change inner_rank if rank < 2)r[rr)r6r2r[new_num_row_partitionss r=_with_inner_rankz#DynamicRaggedShape._with_inner_ranks] 99D | @ AA  t  = >> $j0  * *+A BBrJc|j}| tdt|ts td|dkr td||jk(r|S||k\r td||jkDr||jz }|j|z }|j d}g}t |D]P}|}|j |dz} || z}tj| ||j} |j| R|j|} tt|j|z| S||jksJt|jd||j|j|z S) aCreates an identical shape with the given num_row_partitions. Note that the shape must be statically refactorable to this rank. In particular: * rank must be known. * num_row_partitions must be a nonnegative int. * num_row_partitions must be less than the rank of the shape * num_row_partitions must be greater or equal to the index of any ragged dimension. Note that if the num_row_partitions is the same, self is returned. Args: num_row_partitions: the target num_row_partitions (must be a nonnegative int). Returns: a shape with a (possibly) different num_row_partitions. Raises: ValueError: if the rank is unknown, the argument is not a nonnegative int, or there is a dimension that is nonuniform. Nz/Rank must be known to adjust num_row_partitionsz!num_row_partitions must be an intrz&num_row_partitions must be nonnegative)num_row_partitions must be less than rankr@)rBr&)r[rrsrr*rrangerfrom_uniform_row_lengthr&rDrr0rr$) r6r*r[num_row_partitions_diffrrCmore_rpirB row_lengthr9 alt_inners r=rz+DynamicRaggedShape._with_num_row_partitions5s0 99D | H II (# . : ;;A ? @@T444 kT! B CCD333 2T5L5L Lyy#55n##A&eg,-!**1q51  "  1 1 e4::7r ''7i T%8%8 9G CY OO $"9"9 99 9    11 2    ,> > ?AArJ outer_axis inner_axisctj||jdd}tj||jdd}||kstd|d|d||k(r|S|jdk(r>t |j |j||\}}tg||j| S||jkr|dk(r:t|j|d |j|j|j S|jd |d z }|j|d }|j|d z |}|t|fz|z}t||j|j|j S||jkDrbt |j |j||jz ||jz \}}t|j||j| S|j} | td |dk(r)|j| |z }tj|S|jd |d z } t|j|d z d } |j| |z }||jz } t|j d | d z} t!j"| j%| z}t| |fz|S) a1Merges outer_axis...inner_axis into a single dimension. Returns a copy of this shape with the specified range of dimensions flattened into a single dimension, with elements in row-major order. #### Examples: >>> tf.experimental.DynamicRaggedShape.from_lengths([2, (2,1), ... (1,2,3)])._merge_dims(0, 1) >>> tf.experimental.DynamicRaggedShape.from_lengths([2, (2,1), ... (1,2,3)])._merge_dims(1, 2) >>> tf.experimental.DynamicRaggedShape.from_lengths([2, (2,1), ... (1,2,3)])._merge_dims(0, 2) To mimic the behavior of `np.flatten` (which flattens all dimensions), use `rt.merge_dims(0, -1). To mimic the behavior of `tf.layers.Flatten` (which flattens all dimensions except the outermost batch dimension), use `rt.merge_dims(1, -1)`. Args: outer_axis: `int`: The first dimension in the range of dimensions to merge. May be negative if `self.shape.rank` is statically known. inner_axis: `int`: The last dimension in the range of dimensions to merge. May be negative if `self.shape.rank` is statically known. Returns: A copy of this shape, with the specified dimensions merged into a single dimension. The returned shape will be `self.shape[:outer_axis] + [N] + self.shape[inner_axis + 1:]`, where `N` is the total number of slices in the merged dimensions. rz rank(self)) axis_name ndims_namerzExpected outer_axis (z*) to be less than or equal to inner_axis (z).r)r&r%Nr@zOCannot merge_dims of the inner shape if the dimension of inner_shape is unknown)rget_positive_axisr[rr*_merge_inner_shaperir/r0r&r,rj_merge_row_partitionsrrrrfrom_row_splits row_splits)r6rrrr< prefix_rp suffix_rp internal_rpr;r[prefixsuffixnum_merged_innerprod tail_suffixs r= _merge_dimszDynamicRaggedShape._merge_dimslsH,,DII,PJ,,DII,PJ  # .zl;//9l"> ??Z k !#"4D4E4E484L4L4> "L  /&*jj3IKKT,,, q!   -   **#77 9 9 && Q7i&&z{3i((a Ck1+>@@9Lf      !55 77 d-- - 3E   T55 t.. . t.. .30/.     3 55YYd ?@ @ q//z0AB!33ODD%%ozA~6&t';';JNO'LM//z0AB%(?(??!$"3"3A6F6J"KL"2263D3D3F3MN !&K>"9?KKrJch||jk(r|St|j|j|S)zChange the dtype of the shape.r')r&r0r$rjr6r&s r=r}zDynamicRaggedShape.with_dtypes3   k    t//u>>rJct|j|j}|j|}|j|}t|j|jDcgc]\}}|j |}}}|j tjk(r |j ntj}|jj|j} |j} t|| |d| Scc}}w)aMerge two shapes that are equal modulo num_row_partitions. The resulting num_row_partitions is the maximum of the two num_row_partitions. Args: other: a DynamicRaggedShape representing the same shape with a possibly different number of row partitions. Returns: A DynamicRaggedShape with the same shape and the maximum of the num_row_partitions of the two shapes. T)maxr*rzipr,_merge_precomputed_encodingsr&r rzr{r/rrir0 r6othermax_num_row_partitionsabrp_arp_br new_dtyper<rs r= _merge_withzDynamicRaggedShape._merge_withs!!8!8!&!9!9; %%&<=A &&'=>A  1 113D3DE T4 ))$/77fll2 I22== nnO 0/9"$: <<&C=ct|j|j}|j|}|j|}t|j|jDcgc]\}}|j |}}}|j tjk(r |j ntj}|jj|j} |j} t|| |d| Scc}}w)z'Merge a spec with a DynamicRaggedShape.T)rr*rrr,_merge_with_specr&r rzr{r/rrir0rs r=r*z#DynamicRaggedShape._merge_with_specs!!8!8!&!9!9; %%&<=A &&'=>A  1 113D3DE T4 d#77fll2 I22== nnO 0/9"$: <<r(c|j}| td|dkr td|j|dz }|jS)aEReturns row partitions representing this shape. In order to represent a shape as row partitions, the rank of the shape must be known, and the shape must have rank at least one. Returns: A list of RowPartition objects. Raises: ValueError, if the shape cannot be represented by RowPartitions. z)rank must be known for _as_row_partitionsr@z(rank must be >= 1 for _as_row_partitions)r[rrr$)r6r[ fully_raggeds r=_as_row_partitionsz%DynamicRaggedShape._as_row_partitionssQ 99D | B CC  A BB00:L  & &&rJc|jrltj|jdjt j ||j dd}tj|g|S|S)z5Test if flat_values have the right nvals dynamically.rW)out_typer.Last row partition does not match flat_values.rp) r$rrrCrrXr&rr)r6 flat_values assert_ops r=!_validate_flat_values_dynamicallyz4DynamicRaggedShape._validate_flat_values_dynamically%sj ((   b ! ' ' ) //+ ;A >BDi / / [ II rJct|tjs|S|jr|jd}|j}||j |S|d}t|t jr |j}||j |S|j}||j |S||k7r td|S)z)Test if flat_values have the right nvals.rWrr0) rsrdrer$rXr3rrrSrr)r6r1rflat_values_shapefirst_dim_flat_valuesrs r=_validate_flat_valuesz(DynamicRaggedShape._validate_flat_values/s k:#4#4 5  ..r2%++  "55kBB/2 )<+A+A B 5 ; ;  &55kBB'44l  55kBB , .IJJ rJc|jr?|r|j|}tjj ||jdS|S)aAdd row partitions to flat_values, if necessary. If the shape is truly ragged, then this adds the row_partitions. The shape is dense, then this just returns flat_values. Args: flat_values: the flat_values of a ragged tensor with this shape, or a dense tensor with this shape. validate: validate the flat_values have the right first dimension. Returns: flat_values reshaped to have row_partitions. Frk)r$r7rrc_from_nested_row_partitions)r6r1rks r=_add_row_partitionsz&DynamicRaggedShape._add_row_partitionsDsT  00=  ' ' C C t**UD<<rJc DeZdZdZdeedfdejdejfdZ dZ e de d dffd Ze d e d edejd dfd Ze ej"fdedej(ej,fdejd dfdZed ejfdZed eefdZed efdZed eefdZded eefdZded eefdZdejd dfdZ d dZ!ded dfdZ"ded dfdZ#ded dfdZ$dZ%xZ&S)!r z9A Spec for DynamicRaggedShape: similar to a static shape.r$.r%r&c t|ts tdt|}t j |}t j|}td|Ds td|t jk7r|t jk7r td|D]/}|j|k7std|d|jd|t|}|j}|dk(r|rtd g}tt|D]}||}t j |j"} |dkDrD||d z } | j%| j&} | j%|d | j(z} |j+| |rp|d } |d | j(zj%| j&} |-| j%t j,|d} | |d d z}|j+| tt|d z dd D]<}||d z j%t/||||d z j(||d z <>t1|Dcgc]E\}}t3||j4|j(||d zj4|j G}}}||_t9j:|g||_||_y cc}}w)aYCreate a Spec given row partitions, a static inner shape, and a dtype. Args: row_partitions: A sequence of `RowPartitionSpec`s describing how the ragged shape is partitioned. static_inner_shape: The static shape of the flat_values. dtype: The DType used to encode the shape (tf.int64 or tf.int32). z$row_partitions should be an Iterablec3<K|]}t|tywN)rsr).0r9s r= z3DynamicRaggedShape.Spec.__init__..ssKbB 01Ksz9row_partitions should be an Iterable of RowPartitionSpecs"dtype must be tf.int32 or tf.int64z dtype of z is z : expected rz8If row_partitions are provided, must have inner_rank > 0r@rWN)rBr)rCr&r') rsrrtr|ras_shaper as_dtypeallrzr{rr&r[rrrrBrrCr)rDdimension_at_index_safe_floor_divrrrSr/rdrfrir,) r6r$r%r&rr2num_slices_in_dimensionrr9rF previous_rplast_rps r=rz DynamicRaggedShape.Spec.__init__^s& 1>??^,n'001CDooe$e KNK K GI I &,, 5FLL#8=>>!J$ :: $djj^;uiHJ JJ ^,n%**j q HJ J#% s>*+ 1Aa "))"((3& U(Q/K&&{'8'89F&&'>r'B'2'E'E(FGF ! ( ( 0 1 "2&'+B/../0: 7==0I   #&&//0BAFHF!'* ? 4::. " #$rJrSr!cttj||}tj|j|j |j jS)z(Create a Spec from a DynamicRaggedShape.r#)superr0r1 from_valuer,r/rir&)rrSinitial __class__s r=rPz"DynamicRaggedShape.Spec.from_valuesX (--s>uEg $ $ 00$88$$**%,,rJrXr*c 6|tjk7r|tjk7r tdt j |}|j Mt|Dcgc]}t|}}tj|t jd|S|j dkr%|r tdtjg||S|j |kr tdt j|d}g}t|D]I}t j||dz} | |d} n|| z} |jt|| | | | }Kt j|g||dzdz} tj|| |Scc}w) aCreates a `DynamicRaggedShape.Spec` corresponding to a `tf.TensorShape`. It is assumed that this is a `tf.TensorShape` coming from a `tf.TensorSpec`, not from `RaggedTensor.shape`. In addition to the shape, we need to know the number of row partitions, and the dtype used in the shape (tf.int32 or tf.int64). Within the dimensions that are partitioned, all dimensions are assumed to be uniform. Args: shape: a TensorShape. num_row_partitions: the ragged rank of the RaggedShape. dtype: the dtype of the shape (not the tensor); tf.int64 or tf.int32. Returns: a DynamicRaggedShape.Spec representing a TensorShape. rBNr'r#r@zAnum_row_partitions should be zero if shape is a scalar or vector.rrrA)r rzr{rrrCr[rrr0r1rrrD) rrXr*r&_r$num_elements_so_farrp_specsr current_dimrCr%s r=r3z*DynamicRaggedShape.Spec._from_tensor_shapes, &,, 5FLL#8=>>##E*e  389K3L ./ 5 )  "&&)+77='  q => >!&&%u'F F ) )DEE(88qBh'( $!"225Q<@  "5"=%% 3% )#.    $ $(33  !#();a)?)@#AB  $ $!/%K s FrcBt|tjr|St|tjr1|j |j |j|jSt|tjr|j |j d|Sy)a#Create a TypeSpec for the shape of an object with a given TypeSpec. I.e., if `x_spec = tf.type_spec_from_value(x)`, then `DynamicRaggedShape.from_spec(x_spec)` returns a TypeSpec compatible with `tf.type_spec_from_value(tf.shape(x))`. >>> rt = tf.ragged.constant([[1, 2], [3], [4, 5, 6]]) >>> rt_spec = tf.type_spec_from_value(rt) >>> rt_shape = DynamicRaggedShape.from_tensor(rt) >>> shape_spec_1 = tf.type_spec_from_value(rt_shape) >>> shape_spec_2 = DynamicRaggedShape.Spec._from_spec(rt_spec) >>> assert shape_spec_1.is_compatible_with(shape_spec_2) Args: spec: a Spec of a Tensor or RaggedTensor. dtype: the default dtype (if necessary). Returns: A Spec of the shape of a Tensor or RaggedTensor. r)rXr*r&N) rsr0r1rr\r3rXrYrZrdrf)rrr&s r= _from_specz"DynamicRaggedShape.Spec._from_specs: D,11 2 dM:: ;%%djj$2B2B&*&;&;= = dJ11 2%%**%&A A 3rJc.|jjSr?rrs r=r&zDynamicRaggedShape.Spec.dtype?s    $ $$rJc|jj|jjS|jjjyt j |jjdSNr)r/r[rirXrrrs r=r2z"DynamicRaggedShape.Spec.inner_rankCsc ! ! & & 2'',,,   % % -  ) )$*;*;*A*A!*D EErJc,t|jSr?rrs r=r*z*DynamicRaggedShape.Spec.num_row_partitionsKs %% &&rJc@|j}|dS||jzSr?rrs r=r[zDynamicRaggedShape.Spec.rankOs&??j'TQZ$:Q:Q-QQrJrc|dk(rn|jr|jdjS|jy|jdk(r tdt j |j dS|t|jkr|j|dz jS||jz }|jy|j|krtd|dt j |j |S)z5Get the size of dimension index, if known statically.rNzIndex out of range: 0.r@zIndex out of range: .) r,rBr2rrrr/rr)r*)r6rrelative_indexs r=r4z"DynamicRaggedShape.Spec._dimensionTs !   %%a(.. . __ $ __ !34 4--d.F.Fq.IJ J #d**+ +##EAI.AAAt666n   ??n ,/wa899++  $ $^ 46 6rJrc`t|ts tdtj||j d}|dk(r|j dS||jkr|j|dz jS||jdz z }|jd|}|jS)auThe total size of a dimension (like nvals). This is a static version of DynamicRaggedShape._num_slices_in_dimension() Example: ``` shape = DynamicRaggedShape.Spec( _row_partitions=[ RowPartitionSpec(nrows=3, nvals=14, dtype=tf.int32) RowPartitionSpec(nrows=14, nvals=25, dtype=tf.int32) ], _static_inner_shape=tf.TensorShape([25, 3, 4]), _inner_shape=tf.TensorSpec(tf.TensorShape([3]), dtype=tf.int32)) shape._num_slices_in_dimension(0) = 3 shape._num_slices_in_dimension(1) = 14 shape._num_slices_in_dimension(2) = 25 shape._num_slices_in_dimension(3) = 3 shape._num_slices_in_dimension(4) = 4 shape._num_slices_in_dimension(-2) = 3 ``` Args: axis: the last dimension to include. Returns: the number of values in a dimension. rr[)r rr@N) rsrrtrr r[r4r*r,rCr/ num_elements)r6rrhead_inner_shapes r=rz0DynamicRaggedShape.Spec._num_slices_in_dimensionls<c "122  ( (tyyV Ld q!! (( (##D1H-333$11A56i11*9=  * * ,,rJc|jDcgc]}|j|}}tj||j|Scc}w)z1Return the same spec, but with a different DType.r#)r,r}r0r1r/)r6r&r9 new_rp_specss r=r}z"DynamicRaggedShape.Spec.with_dtypesQ595I5IJrbmmE*JlJ  $ $%!55%KsA ct|j|j}|j|}|j|}t|j|jDcgc]\}}|j |}}}j jj }|jtjk(r |jntj}tj|||Scc}}w)a<Merges all information between two specs. Specs are expected to represent the same information modulo num_row_partitons. If the specs are of different ranks, then fail. Args: other: another Spec of the same rank. Returns: a Spec with the union of information. r')rr*rrr,r'r/rr&r rzr{r0r1)r6r r!r"r#r;r<r&s r=r'z#DynamicRaggedShape.Spec._merge_withs #4#:#:#(#;#; =  ' '(> ?a  ( ()? @aA--q/@/@Aq! -- f !44??   !''V\\1agg e  $ $ (%77s&C:rc&|j}| td|t|dz dkDr td|dkr td|j|k(r|S|j|kr||jz }tj j |j||j}tj |j|jz|j|jS|j|kDsJ|jd|}|d}|j|d}tj|jg|Dcgc]}|jc}z|jddz} tj || |jScc}w) z0Change the number of row partitions in the spec.Nz9Changing num_row_partitions with unknown rank unsupportedr@rz"Number of row partitions too largez!Number of row partitions negativer#rW)r[rrr*r0r1r3r/r&r,rrrCr)) r6rr[rp_delta tail_shaperrold_row_partitionsrr<s r=rz0DynamicRaggedShape.Spec._with_num_row_partitionssYYd  GI I #dQh"2 2=>> ! #<== $: :  " "%; ;)D,C,CC',,??  $ $h < !&&//*2L2LL)==**'  &&)????!112I3IJ/3!112H2IJ  $ $#))*/AB!%%BC D  $ $QR ( )  "&&'9'=tzzK KCsF new_rankc| td|dkr td|j}|!||krtdj||||S|jrSt ||j z d}|jdj}tj|gdg|dz zz}ntjdg|z}tj|j||j S) z0Ensures this has a known rank at least new_rank.Nz"new_rank is None, but expected intrzRank must be non-negativez5Rank is {current_rank}, expected at least {new_rank}.) current_rankrlr@rWr#) rtrr[formatr,rr*rCrrr0r1r&)r6rlrnrrr%s r=_set_rank_if_unknownz,DynamicRaggedShape.Spec._set_rank_if_unknowns  <== A455YYl  !lX&= C J J)H K >? ?  !  X(?(??C((,22 )55ykTF7E7IEK7KL*55tfx6GH  $ $--/ %rJc|j |j|j|S|dk(r+tjj gd|j S|dk(r=|jd}tjj |gd|j S||jdzkrW|jd|dz }tj|djg}tj |||j S||jz }|jd|}tj |j||j S)a:Truncate a ragged shape spec. For example, if the original spec s was for a shape: [3, [4, 1], 2, 7] Then truncate_dynamic_ragged_shape_spec(s, 3) is a spec for: [3, [4, 1], 2] Args: new_rank: the new rank Returns: A truncated DynamicRaggedShape.Spec. Nrr@rWr#)r[rp _truncater0r1r3r&r4r*r,rrrCr/)r6rl vector_sizerr<rs r=rrz!DynamicRaggedShape.Spec._truncatesP  ((2<**F F D++a/ /!11-8a<@!-!9!9  # ) ) *",!&&-5**'  t666 !%!9!9*9!E!&&//5**' rJc|}|jjtjdS|jjdk(r|jrJ|jS|j dg}|j |jDcgc]}|jc}|jdd}tj||zScc}w)z.Get a tensor shape corresponding to this type.Nrr@)r/r[rrr,r4extendr))r6altrr9rs r=r]z(DynamicRaggedShape.Spec._to_tensor_shape)s c % % -''-- % % *&&&&&&&q!"f mmS5H5HIrR**IJ&&qr*f  % %f - 66Js C )r r r!r )'r_r`rarbrrrrr DTyperr classmethodrrPrr3r{rrr\rdrfrYpropertyr&rr2r*r[r4rr}r'rrprrr] __classcell__)rRs@r=r1zDynamicRaggedShape.Spec[s%CW,u-=s-B'CW,%1%=%=W, W,r$ ,s,'@,,,BsBB"(,,B3LBBH %ll #A-}/M/M))*+#A|| #A0I #A#AJ%v||%%FHSMFF'C''RhsmRR66 60)-S)-Xc])-V 1J7.73L7B!K&)!K.G!KFS5N8(#(*C(T 7rJr1)NFNr?T)r r0r!r0)r r r!r0)F);r_r`rarbrr__annotations__rdrerrr__batch_encoder__rr TensorLikerr rwrRrrxr{rrrrrrMryr$r*r&rrrr]rr4rrrrr[rjr2rrrrrr}r'r*r-r3r7r;r1rgrJr=r0r0sQ:s*++!!!#///57 $( 04 %)- f' 5f OOfv||,f f $' fP'+b:$U8C=#+=%>?b:b:H H H<< ++     % % # ## 2 2   G G)KVF C85AnjLCjL!jL&:jLX><<<,<1E<('&*.Y7Y7rJr0shape_xshape_yr!ct|ts tdt|ts tdt||dS)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. z$shape_x must be a DynamicRaggedShapez$shape_y must be a DynamicRaggedShaper)rsr0rt broadcast_dynamic_shape_extended)rrs r=broadcast_dynamic_shaper7sD& G/ 0 : ;; G/ 0 : ;; )'7 ;A >>rJrXct|ts tdtj|}d}tj |rx|j dk7r.|jj|jk7r0td|j|jj}tj|}nv|j dk7r"tj||j}nEtj|tj}|jtj}t||}|j|S)aBroadcasts a potentially ragged tensor to a ragged shape. Tiles `rt_input` as necessary to match the given shape. Behavior is undefined if `rt_input` is not broadcast-compatible with `shape`. Args: rt_input: The potentially ragged tensor to broadcast. shape: A `DynamicRaggedShape` Returns: A potentially ragged tensor whose values are taken from `rt_input`, and whose shape matches `shape`. z"shape must be a DynamicRaggedShapeNrzCannot coerce row_splits.dtyper')rsr0rtr"convert_to_tensor_or_ragged_tensorrr*rr&rr}rMr r{_get_broadcaster broadcast)rt_inputrX origin_shape broadcasters r= broadcast_torRs E- . 8 99  = =h G(,X& 1$    " "ekk 19::x22889e%11(;L 1$'33HEKK3Pl'33 &,,4(lV\\2e u5+   x ((rJr"r#c |jr0|jr$|j|jk7rtd|j|jk7r|jr|j|j}nf|jr|j|j}n>|jtj }|jtj }|j |j td|j dk(r|t||gt|fS|j dk(r|t|t||gfS|j dk(re|j dk(rVt|j|j\}}}tj|}|t|||gt|||gfS|j |j kDrt||\}}}|||fSt||S)aAGets the smallest shape to which a and b can broadcast. In order to create the smallest shape, one must also do most of the work to figure out how to transform from the shapes given. Thus, in addition to returning the shape, it also creates transformations from the original shapes to the result. This is the equivalent of: c = broadcast_dynamic_shape(a, b) ac = get_broadcaster(a, c) bc = get_broadcaster(b, c) return (c, ac, bc) Args: a: a DynamicRaggedShape b: a DynamicRaggedShape Returns: A triple of a shape and two broadcasters. zDtypes don't matchz!Unable to broadcast: unknown rankrr@)r$r&rr}r r{r[ _Broadcaster_get_identity_broadcaster"_broadcast_dynamic_shape_one_layerrjr0r(_broadcast_dynamic_shape_extended_helper) r"r#a_layerb_layertarget target_shapecbcacs r=rrxs0!**ww!'' + ,,ww!'' ,,qww a   ,,qww a ,,v|| $a ,,v|| $affn 8 99vv{ |Aq"%'@'C DDvv{ (+\!Q-C DDvv{qvv{1!--O Wg %77?L ,q, B L7) 4 66VVaff_:1a@KQB r2; 1!Q 77rJc|j|jk(xr0tdt|j|jDS)z.s!MNAa1fMNs)r*rErr$)shape_ashape_bs r=_row_partitions_identicalrsO  % %)C)C C NMNW33W5K5KLMNJNOrJcPtj|}tj|}tj||r |jnd}tj||j}|r|rtj||\}}|r|st|r7|j j j|j jks;|rB|j j j|j jkr tj|}tj|}|j|jk7r;|s|j|j}n|s|j|j}t||r.|j||j |j dSt||\}}} |j|d} | j|d} || | } |j| dStj|r |j n|} tj|r |j n|}|| |}t|t r|Stj|r|j#|S|j#|S)z1Binary elementwise api handler for RaggedTensors.Npreferred_dtypeFr9inner_dimensionsT)rrrr&match_row_splits_dtypesr1rXndimsr0rMr}rr;rbroadcast_flat_valuesrsrRwith_flat_values)opry x_is_ragged y_is_raggedrrshape_zbcast_xzbcast_yz x_new_flat y_new_flatz_flatx_valuesy_values mapped_valuess r=!ragged_binary_elementwise_op_implrs7''*+''*+66[!''d=!66"![  0 0A 6DAq{q}}**00AGGMMAq}}**00AGGMMA ,,Q/G ,,Q/G}} % $$W]]3$$W]]3 '2  ( ( Q]]AMM *) 2'7CWh //E/JJ//E/JJ  J 'F  & &v & ==+55a8Q]]a(+55a8Q]]a(Xx(- t$ Q  m ,,  m ,,rJcttj|}tj|}tj||r |jnd}tj||j}|r|rtj||\}}|r|ss|r7|j j j|j jks:|r|j j j|j jkrtj|}tj|}|j|jk7r;|s|j|j}n|s|j|j}t||r||j |j St||\}}} |j|d} | j|d} || | Stj|r |j n|} tj|r |j n|} || | S)aBinary elementwise assert api handler for RaggedTensors. This handles binary assert operations for ragged tensors. Compared with `ragged_binary_elementwise_op_impl`, this handler does not compute a ragged tensor as output. Instead, it applies the assert operation `op` to input tensors based on their ragged shapes and flat_values, and returns the result of the assertion operation. Args: op: a binary assert operation on Tensors. x: something that can be coerced to a Tensor or RaggedTensor. y: something that can be coerced to a Tensor or RaggedTensor. Returns: the result of the assertion operation. NrFr)rrrr&rr1rXrr0rMr}rrr)rrrrrrrrTrrrrrrs r=(ragged_binary_elementwise_assert_op_implrs(''*+''*+66[!''d=!66"![  0 0A 6DAq{q}}**00AGGMMAq}}**00AGGMMA ,,Q/G ,,Q/G}} % $$W]]3$$W]]3 '2  q}} -->wPQ(//E/JJ//E/JJ j* %%+55a8Q]]a(+55a8Q]]a( Hh rJcD||St|tr |jSt|tjr|St|t ryt|t ryt|tryt|tjr |jS|jS)zHelper for _find_dtype.N) rsrr&r rwrrr|rre)rS preferreds r=_find_dtype_helperr$s~ %& ;;%& L% % % %% ;; rJct||}|tjk(s|tjk(s||St dt |z)aReturns the preferred dtype of value or preferred if preferred != None. This is used as an operator to pass over multiple objects in decreasing order of priority until there is a preferred dtype for one. For example, if you were adding three tensor-ish things (some tensors, some lists), and needed a preferred dtype, you could use this as: def adding(a, b, c, dtype = None): dtype = _find_dtype(a, dtype) dtype = _find_dtype(b, dtype) dtype = _find_dtype(c, dtype) if dtype is None: dtype = tf.float32 ...Code continues here... Args: value: a list, value, RowPartition, or tensor. preferred: a given dtype. If not None, this will be returned. Returns: an optional dtype. zIllegal dtype: )rr r{rzrru)rSrrFs r=rwrw7sE. eY /&  &,, 6&. M$s6{233rJiterabler&c4||S|D]}t||}|S)aTFind the preferred dtype of a list of objects. This will go over the iterable, and use the first object with a preferred dtype. The dtype passed has highest priority if it is not None. Args: iterable: an iterable with things that might have a dtype. dtype: an overriding dtype, or None. Returns: an optional dtype. )rw)rr&rs r=rvrvTs/  L "a 5 !E" ,rJceZdZdZeej dZedZej dZ dZ e dZ e dZ e dZej d Ze dd Zd Zd ZdZdZy )_LayerBroadcasteraJA broadcaster of a single layer. Although this class does not literally contain a gather_index, the reference implementation is defined through a gather_index. Thus, any subclasses should first define the gather_index property. Other functions can be overridden for optimization, but it should not change the behavior. cy)zReturns a 1D tensor. The size of the 1D tensor is equal to the destination size. The ith element of the result is the index of the source of the ith element. Nrgrs r= gather_indexz_LayerBroadcaster.gather_indexss rJc.|jjS)z#Returns the dtype of the broadcast.)rr&rs r=r&z_LayerBroadcaster.dtype~rrJcy)z>Returns an identical _LayerBroadcaster with a different dtype.Nrgrs r=r}z_LayerBroadcaster.with_dtypes rJc,t|jSr?)rurrs r=rz_LayerBroadcaster.__repr__s t  !!rJct|Sz)Create a broadcaster from a gather_index.)_GatherLayerBroadcaster)rrs r=from_gather_indexz#_LayerBroadcaster.from_gather_indexs #< 00rJcDt||}tj|Sr)_first_layer_gather_indexrr)r nrows_source nrows_targetrs r= first_layerz_LayerBroadcaster.first_layers!-\<HL  . .| <>%u#E FFrJcBtj||jS)a+Broadcast from a dense tensor. It is assumed that the first axis of the dense tensor is indexed by the source shape, and at the end, the first axis of the dense tensor is indexed by the destination shape. Args: tensor: a dense tensor. Returns: A dense tensor. )rgatherr)r6r s r=broadcast_tensorz"_LayerBroadcaster.broadcast_tensors   FD$5$5 66rJctjtj|jd|j S)zEReturn the number of rows in the resulting gather, or None if tiling.rr')rrrrXrr&rs r= dest_nrowsz_LayerBroadcaster.dest_nrowss2 ==))*1-TZZ AArJc,|js2tj|j|j Stj |j |j |jz|jS)aReturn a new shape where the rows are broadcasted. *--self--->* | | rp result | | V V *--------->* This is equivalent to: return RowPartition.from_row_lengths(self.broadcast(rp.row_lengths())) However, if the shape has uniform row length, then that property is maintained. Args: rp: a row partition. Returns: a RowPartition representing a broadcast version of this row partition. rCrB)rrfrom_row_lengthsrrrr)r)r6r9s r=broadcast_row_partitionz)_LayerBroadcaster.broadcast_row_partitionsx, ==?  * *    0 133 1 1   !%%'$//*;;!##rJcFt|||}tj|S)aCreate the next layer gather_index whether or not a broadcast happens. *---------self------->* | | original_rp broadcast_rp | | \|/ \|/ *--next_broadcaster-->* Args: original_rp: the original row partition. broadcast_rp: the target row partition. Returns: the gather_index for next_broadcaster. )_next_layer_gather_indexrr)r6 original_rp broadcast_rprs r= next_layerz_LayerBroadcaster.next_layers#",D+|LL  . .| <=rJrc2eZdZdZdZedZdZdZy)rzImplements _LayerBroadcaster with an explicit gather_index. For example, suppose that the source shape is: [*],[*,*] And the target shape is: [*],[*,*],[*],[*,*] Then, this can be represented with a map: [0,1,2,0,1,2] ctj|}|jtjk7r(|jtj k7r t d||_y)Nz#gather_index must be int64 or int32)r r~r&r r{rzr _gather_index)r6rs r=rz _GatherLayerBroadcaster.__init__ sJ((6Lfll*fll* < ==%DrJc|jSr?)rrs r=rz$_GatherLayerBroadcaster.gather_index   rJcTttj|j|Sr?)rrrrrs r=r}z"_GatherLayerBroadcaster.with_dtypes "8==1C1CU#K LLrJcXtj||j}t|Sr?)rrrr)r6rnew_gather_indexs r=rz)_GatherLayerBroadcaster.with_dependenciess*'99""$ "#3 44rJN) r_r`rarbrryrr}rrgrJr=rrs+ &  M5rJrcjeZdZdZ d dZdZdZedZedZ edZ d Z d d Z d Z y)rzA _Broadcaster represents a transformation from one shape to another. It provides a transform for each axis of the source shape to the corresponding axis of the destination shape. Nc@t|ts tdt|ts tdt|tstdt |z|D])}t|t rtdt |zt ||}t ||}t||}t tj|}|j||_ |j||_ |Dcgc]}|j|c}|_ ycc}w)a Create a broadcaster. Do not call directly. The source_shape, target_shape, and layer_broadcasters are converted to have the same dtype. Note: source_shape.rank and target_shape.rank must be known. Args: source_shape: the source DynamicRaggedShape target_shape: the target DynamicRaggedShape layer_broadcasters: List[_LayerBroadcaster] of length source_shape.rank. dtype: the preferred dtype of the broadcaster. Raises: TypeError: if the input types don't match. z(source_shape is not a DynamicRaggedShapez(target_shape is not a DynamicRaggedShapezlayer_broadcasters not a list: zNot a LayerBroadcaster: N)rsr0rtrrurrwrvr r{r} _source_shape _target_shape_layer_broadcasters)r6 source_shaperlayer_broadcastersr&rrs r=rz_Broadcaster.__init__(s* l$6 7 @ AA l$6 7 @ AA ($ / 7,-. // > - .2SW<==>  e ,E  e ,E !3U ;E  e ,E%007D%007D=OP U 3PDPs:Dcdt|jzdzt|jzdzt|jzdzS)Nz {src_shape:z, target_shape:z layer_broadcasters: })rurrrrs r=rz_Broadcaster.__repr__PsV C 2 23 36G G "" # $&= > (( ) *,/ 01rJcZt|j|j|j|S)z9Return a copy of this Broadcaster with a different dtype.)rrrrrs r=r}z_Broadcaster.with_dtypeUs* **D,>,>00% 99rJc|jSr?)rrs r=rz_Broadcaster.source_shapeZrrJc|jSr?)rrs r=rz_Broadcaster.target_shape^rrJc.|jjSr?)rr&rs r=r&z_Broadcaster.dtypebs    # ##rJc|jj}|jtjk(r%t j |tj}|SrL)rrjr&r r{rrrz)r6rs r=_target_inner_shape_int32z&_Broadcaster._target_inner_shape_int32fs?''33O , oV\\Jo rJctj|r |j}|jjdk(r|S|jj }||j jkDr|jjdkDrCtj||jj|jj}|r$tj||jS|S|j j |k7r/tj||j j|}|j| }|j|}|r$tj||j}|S)aflat_values of a ragged tensor broadcast to target_shape. If inner_dimensions==True, then the result is a dense tensor with shape target_shape.inner_shape, the flat values of the broadcasted shape. If you add target_shape.row_partitions, you will get the full broadcasted shape. If inner_dimensions==False, the result is a dense tensor that satsifies certain properties: 1. broadcast_to(result, target_shape.inner_shape) will give the result if inner_dimensions==True. 2. Either (a) (result.rank < target_shape.inner_rank) or (b) (result.shape[0] == target_shape.inner_shape[0]). 3. result.rank = min(target_shape.inner_rank, rt.rank) 4. For i < target_shape.inner_rank - 1, and i < rt.rank, and if rt.shape[-i]!=1, then result.shape[-i]=target_shape[-i]. Args: rt: a ragged or dense tensor. inner_dimensions: if true, broadcast the inner dimensions as well. Returns: a dense tensor r)rrr1rr[r2rrr*rreshaperrrrr)r6rtrr2flat_broadcasters r=rz"_Broadcaster.broadcast_flat_valuesmsK2r" >>b " i""--JD&&+++    - - 1    !!2243D3D3I3IJL %%b$*H*H*JKK i   & &* 4   r#11BB:NP11:+>  , ,R 0b   # #B(F(F(H I irJcZ|j|}|jj|S)z3Broadcast a tensor of source_shape to target_shape.)rrr;)r6rr1s r=rz_Broadcaster.broadcasts),,R0K    0 0 ==rJr?r{)r_r`rarbrrr}ryrrr&rrrrgrJr=rr si &QP1 9      $ $4l>rJrct|tstdt|zt |t |k(sJ|s|gS|j |d|d}t ||dd|dd}|g|zS)aGet LayerBroadcasters from RowPartitions. *--zero_broadcaster->* | | source_rps[0] target_rps[0] | | V V *---result[1]------->* | | source_rps[1] target_rps[1] | | V V *---result[2]------->* . . . *---result[k-1]----->* | | source_rps[k] target_rps[k] | | V V *---result[k]------->* Note: result[0] = zero_broadcaster Args: zero_broadcaster: a broadcaster between the source and target row partitions' rows, and equal to result[0]. source_rps: source row partitions. target_rps: target row partitions (same length as source_rps). Returns: result: a list of LayerBroadcasters. zNot a _LayerBroadcaster: rr@N)rsrrtrurr _get_layer_broadcasters_from_rps)zero_broadcaster source_rps target_rpsnext_broadcastertail_broadcasterss r=rrsF $&7 8 /#6F2GG HH ZC O ++ +   %00A 1 N67G7A!"~7A!"~G  / //rJc|j|jk7r td|j |j td|j|jkDr td|jdk(r t||gS|jdk(rO|jdk(sJtj |j d|j d}t|||gS|j|jksJ|jdk\sJ|jdk\sJ|j}|j}t|dk\sJt|t|ksJ|d}t|t|krtj|d|}|t|dz }tj|j}|j||} t|dk\r|t| dng} t| || } t||| St|t|k(sJtj |dj|dj} t| ||} t||| S) z5Get a _Broadcaster from source_shape to target_shape.z6The source and target row_split dtypes should be equalNz2Rank of source and target must be statically knownz-Cannot broadcast to a shape with smaller rankrr@rr)rBrC)r&rr[rrrrjr-rrrrrBrr) rrlayerrr source_nrowsneg_one_source_rpneg_one_target_rpneg_one_broadcasterzeroth_broadcastertarget_rps_taillayerss r=rrs<--- M NN<#4#4#< I JJ<,,, D EEA  lB 77A    !! !  ) ),*B*B1*E*6*B*B1*E GE  lUG <<   l// // /   a     a  ..0*..0* ZA   ZC O ++ +a,_s:&%<<'q F"S_q%8#9:+EE!#,778I8IK7:88j#j/!1!23 ..@*.=?F  lF ;; z?c*o -- -*66z!}7J7J7L7A!}7J7J7LN -.@*.8:F  lF ;;rJc|j tdt|jDcgc]&}tj |j |(}}t |||Scc}w)z,Gets a Broadcaster for two identical shapes.zShape must have a defined rank)r[rrrrrr)rXrrs r=rr so ZZ 5 667.broadcast_from_a1 s7ooc3GnnS!G F Wf %%rJr@c~tj}tjj}}|||gSrLrrrrr&)rrrr"a_0s r=broadcast_from_bz<_broadcast_dynamic_shape_one_layer..broadcast_from_b? s7nnS!Gooc3G F Wf %%rJcftj}tj}}|||gSr?rr)rrrrr#rs r=broadcast_noopz:_broadcast_dynamic_shape_one_layer..broadcast_noopM s1nnS!GnnS!G F Wf %%rJc4tjSNtrue_fnfalse_fnrrrcan_broadcast_from_bsr=broadcast_not_from_az@_broadcast_dynamic_shape_one_layer..broadcast_not_from_aW  99&6 QQrJTCannot broadcastrpr) rrrrrequal logical_orrrrrr)r"r#ra_statica_gib_girrrb_staticcan_broadcast_from_ar$ nrows_equal can_broadcastcheck_can_broadcastresultsrrrrrr#s`` @@@@@r=rr s !# !#& ' ' *( hqkQ.+-T411$7G11$7G Wf %%& ' ' *( hqkQ.+-T411$7G11$7G Wf %%&"Q/!Q/QsC(+%%. <>-"..T#57 II# %'  ((*=)>B ' !4v  / / 5'  / / 5' 7F ## s>Gc  fd}tj}tj}|Y||k(r%tj|j}||gS|dk(r*tj tjgS|dk(r*tjtj gSfd fd t jtjdj}t jtjdj fd}t jt j| t j}tj|||} | D cgc]@} tjtjtj |dg| Bc} Scc} w) a{Broadcast the first layer of two dynamic shapes given the dimensions. Args: a_0: the number of rows in a. b_0: the number of rows in b. Returns: (use_a, layer_a, layer_b) where use_a is true if the target provably equals a, false otherwise. layer_a is a _LayerBroadcaster from a to the target. layer_b is a _LayerBroadcaster from b to the target. cxtjj}tj}||gSrLr)rrrs r=rz>_broadcast_dynamic_shape_first_layer..broadcast_from_a s0ooc3GnnS!G W rJr'r@cxtj}tjj}||gSrLr)rrrs r=rz>_broadcast_dynamic_shape_first_layer..broadcast_from_b s0nnS!Gooc3G W rJc`tj}tj}||gSr?r)rrrrs r=rz<_broadcast_dynamic_shape_first_layer..broadcast_noop s*nnS!GnnS!G W rJc4tjSrrr"sr=r$zB_broadcast_dynamic_shape_first_layer..broadcast_not_from_a r%rJrT)rrrrr&rrr'r rr(rrrrrr)rrr static_a_0 static_b_0id_broadcasterr-r$r/rFrrrr#s`` @@@r=$_broadcast_dynamic_shape_first_layerr:r s ))#.*))#.*Z(AA CIIB'nn -- q  5 5c :  4 4S 9 1_223733C8    "[-A-A!SYY-OP![-A-A!SYY-OPQ %%.0DEnnS# - 99# %&KQ FG))  , ,%%mT:;Q @A  sAGac_0a_1c|j|}tj|j|j }tj|j |}||j z}tj||gS)aDoes a NOOP broadcast of a_1. *-ac_0-->* | | a_1 c_1 | | V V *-ac_1-->* Note that by definition this cannot fail: there is always a well-defined NOOP broadcast. This is usually intended as half of broadcasting two shapes together. Args: ac_0: previous LayerBroadcaster a_1: previous RowPartition Returns: [ac_1, c_1] where ac_1 is the next LayerBroadcaster, and c_1 is the broadcast RowPartition ) rrrr value_rowidsroffsets_in_rowsrr)r;r<c_1old_value_rowidsold_row_startsrs r=_broadcast_halfrC sy. $$S)#%%d&7&79I9I9KL##CNN$46FG.#"5"5"77,  - -l ;S AArJbc_0b_1ctts tdtts tdtts tdtts tdj sJj rJt j j}|dk(rt\}}tjj|j}tj|j}tj|} tj|j}|| |gSfd} fd} t!j"jd} t%j$| | | \} }}tj| }tj|} tj|}|| |gS) aBroadcast target and next layer broadcaster of two dynamic shapes. a_1 is uniform, and b_1 is ragged. *--ac_0-->*<--bc_0--* | | | a_1 c_1 b_1 | | | V V V *--ac_1-->*<--bc_1--* Args: ac_0: _LayerBroadcaster from a to c in the previous layer. bc_0: _LayerBroadcaster from b to c in the previous layer. a_1: a uniform RowPartition for the next layer of a. b_1: a ragged RowPartition for the next layer of b. Returns: (c_1, ac_1, bc_1) c_1: a RowPartition for the next layer of the dynamic shape. ac_1: _LayerBroadcaster from a to c in the next layer. bc_1: _LayerBroadcaster from b to c in the next layer. "ac_0 should be a _LayerBroadcaster"bc_0 should be a _LayerBroadcastera_1 should be a RowPartitionb_1 should be a RowPartitionr@cBt\}}t \}}tj|j|jg}j|j|jfDcgc]}t j ||c}Scc}wr?)rCrrrrrr) ac_1c_1abc_1c_1brrr<r;rErDs r=rzG_broadcast_dynamic_shape_next_layer_half_ragged..broadcast_noop s"4-LT4"4-LT4$$T__%68IJ KF.."D$5$5t7H7HI   **615  s<Bct\}}tjj|j }|j ||jgSr?)rCrrrr>rrNrOac_1_gather_indexr;rErDs r= broadcast_azD_broadcast_dynamic_shape_next_layer_half_ragged..broadcast_a sU"4-LT4!(():):Drrrrr'r)r;rDr<rE static_a_1rNrOrRr@rLrrScan_broadcast_ac_1_row_splitsbc_1_gather_indexs```` r=/_broadcast_dynamic_shape_next_layer_half_raggedrX s4 D+ , 8 99 D+ , 8 99 C & 2 33 C & 2 33    ^^  ))#*@*@*BC*1_"4-LT4!(():):D$ $$^4#  , ,-> ?$  , ,-> ?$ tT rJc tts tdtts tdtts tdtts tdj sJj sJt j j}t j j}|||k(rHt\}}t\}}tj|j} | ||gS|dk(rt\}} tjtjj| j}tjjj} | ||gS|dk(rt\}} tjtjj| j}tjjj} | ||gSfdfd} fd t!j"jdfd } t!j"jd}t%j&t!j(t!j(|t!j"jjd g}t+j*|| | }|Dcgc]}t-j.||c}\}}}tj||jzj } tj|}tj|}| ||gScc}w)aBroadcast target and next layer broadcaster of two uniform dynamic shapes. *--ac_0-->*<--bc_0--* | | | a_1 c_1 b_1 | | | V V V *--ac_1-->*<--bc_1--* Args: ac_0: _LayerBroadcaster from a to c in the previous layer. bc_0: _LayerBroadcaster from b to c in the previous layer. a_1: a RowPartition for the next layer of a. b_1: a RowPartition for the next layer of b. Returns: (c_1, ac_1, bc_1) c_1: a RowPartition for the next layer of the dynamic shape. ac_1: _LayerBroadcaster from a to c in the next layer. bc_1: _LayerBroadcaster from b to c in the next layer. rGrHrIrJ)rBr@ct\}}t\}}j|j|jgSr?)rCr)r)rLrTrNr<r;rErDs r=rzH_broadcast_dynamic_shape_next_layer_both_uniform..broadcast_noopj sG c*IT1c*IT1  " " $d&7&79J9J KKrJct\}}tjj|j }j ||jgSr?rCrrrr>r)rQs r=rSzE_broadcast_dynamic_shape_next_layer_both_uniform..broadcast_aq sW"4-LT4!(():):D.broadcast_bz sR"4-LT4!(():):D.no_broadcast_a s 99~ GGrJTrr)rsrrtrrrrr)rCrrrrrrr>rr'rrr(rrr)r;rDr<rErT static_b_1rLrTrNr@rOrMrSrarUbroadcast_assertsrFrc_1_uniform_row_lengthrRrWr^rr`s```` @@@r=0_broadcast_dynamic_shape_next_layer_both_uniformre* sX2 D+ , 8 99 D+ , 8 99 C & 2 33 C & 2 33      ))#*@*@*BC*))#*@*@*BC*Z"$,itQ!$,itQ  0 0 DOO- /c4  q$T3/ltT  0 0   4,,d.?.?.A BDd  0 0 "$//*; =c4 1_"4-LT4  . .**D,=,=,?@ BD  . .  (9 ;C t LL NN3#9#9#;Q?/GNN3#9#9#;Q?/   !!/?CnnS335 3357 8:> ? 99{^ E&IODCD(():A>D@,.? ,, "T__%6 6 OO  #  , ,-> ?$  , ,-> ?$ tT Ds7Oct|ts tdt|ts tdt|ts tdt|ts td|j r,|j rt ||||St ||||S|j rt ||||\}}}|||fSt||\}}t||\}}tj|j|jg} |j| |j| |j| fS)aBroadcast target and next layer broadcaster of two dynamic shapes. *--ac_0-->*<--bc_0--* | | | a_1 c_1 b_1 | | | V V V *--ac_1-->*<--bc_1--* Args: ac_0: _LayerBroadcaster from a to c in the previous layer. bc_0: _LayerBroadcaster from b to c in the previous layer. a_1: a RowPartition for the next layer of a. b_1: a RowPartition for the next layer of b. Returns: (c_1, ac_1, bc_1) c_1: a RowPartition for the next layer of the dynamic shape. ac_1: _LayerBroadcaster from a to c in the next layer. bc_1: _LayerBroadcaster from b to c in the next layer. rGrHrIrJ) rsrrtrrrerXrCrrrrr) r;rDr<rEr@rNrLrMrO check_valids r=#_broadcast_dynamic_shape_next_layerrh sP2 D+ , 8 99 D+ , 8 99 C & 2 33 C & 2 33^^ ~~ = c3  = c3   ~~I c3 sD$4 %T3/ltT$T3/ltT  !2DOO4E Fk  ! !+ .   -   -//rJa_zerob_zeroa_rpsb_rpsct|t|k(sJ|rAt|||d|d\}}}t|||dd|dd\}}} |g|z|g|z|g| zfSgggfS)aYCreate BroadcastLayers from two shapes to a target shape. *--a_zero->*<-b_zero-* | | | a_rps[0] c_rps[0] b_rps[0] | | | V V V *--ac[1]-->*<-bc[1]--* | | | a_rps[1] c_rps[0] b_rps[1] | | | V V V *--ac[2]-->*<-bc[2]--* Note: ac[0]=a_zero, and bc[0]=b_zero. Args: a_zero: broadcaster from rows of a_rps[0] to target shape. b_zero: broadcaster from rows of b_rps[0] to target shape. a_rps: RowPartitions of first shape. b_rps: RowPartitions of second shape, equal in length to a_rps. Returns: (c_rps, ac, bc) where: c_rps: RowPartitions of target shape. ac: layers broadcasting from the first shape. bc: layers broadcasting from the second shape. rr@N)rrh!_broadcast_dynamic_shape_from_rps) rirjrkrlr@rLrNc_suffixa_layersb_layerss r=rnrn sB Us5z !! ! 0q16q; S$ 34uQRy389>Xx EH tfx/$(1B CC B<rJc\|jdk(r|jdk(ry|jtd|j|jz z}|jtd|j|jz z}|jdk(r|S|jdk(r|St||S)z9Returns broadcast_dynamic_shape(a, b).num_row_partitions.r)r*rr[)r"r#expanded_num_row_partitions_aexpanded_num_row_partitions_bs r=!_get_broadcast_num_row_partitionsru saA$8$8A$= "#"6"6Q9P"P"#"6"6Q9P"PQ ((Q (( *,I JJrJror bc_suffixc|dt| }|jt|z }t|Dcgc]&}tj |j |(} }t ||} tj|t|z} | j| } | t|| |t|| | |zfScc}w)z,Helper for broadcast_dynamic_shape_extended.N) rr[rrrrrur0rr|rr) r"r#rlrorrvc_prefixbc_prefix_lengthr bc_prefixc_num_row_partitionsc_rawrs r=*_broadcast_dynamic_shape_extended_completer} s ?S]N #(VVc)n,%& 001K1KA1NO);1a@  0 0E(O1K L% $$%9:! \!Q #\!Q I8M%N OOs+B>c |j|jksJd|jksJd|jksJ|j}|j}t|t|kr|d}tj|}||}t j |d|}|t|dz }ttjd|dj|j\}} t|| ||\} } } t|dk\r|t| dng} t| | || \}}}t|||| g|z| g|z| | g|zSt|t|k(sJt|dj|dj\} } t| | ||\}}}t||||| g|z| g|zS)zHelper for broadcast_dynamic_shape_extended. Here, we force: a.rank <= b.rank 2 <= b.rank 1 <= a.rank Args: a: a DynamicRaggedShape b: a DynamicRaggedShape Returns: A triple of a shape and two broadcasters. rr@rNrr')r"r#rlrorrv)r[r-rrrrrr:r rr&rBrhrnr})r"r#rkrla_nrowsa_nrows_static neg_one_a_rp neg_one_b_rp neg_one_ac neg_one_bcc_zeroac_zerobc_zero b_rps_tailro ac_layers bc_layersc_rpsrprqs r=rr/ s 166   aff aff   %   %Z#e*dG //8N!g77"!7*+LCQeAhnn5|7I7I7K MZ 4J 4@,PVW (+E aE {|$RJ4GWe4>@Xy 6 H$ 9y w')3  55 u:U ## #4U1X^^5E5:1X^^5EGW 37GU38:UH 5  9x )h&  ((rJc|dkr| td||z}|dkrd}|dkDr ||dzkr|S|dk(r|S| td||k\r|}|S),Slice indexes are always silently truncated.r:Rank must be known to use __getitem__ on a negative index.r@r)r)rr[r*s r=rr} s} QY |  F HH 5LE QY E1*.gi_broadcast_first s ??<|/A/A BBrJcJtjj}|SrL)rrr&)rrs r=gi_no_broadcast_firstz8_first_layer_gather_index..gi_no_broadcast_first s>>,l6H6HIL rJr@Tr&rpr) rr'r rr&rrr(rrr)rrrr do_broadcastr.r/rs ` r=rr sC + 4 4Q 8J8J KM,|\:+((, 4  "- .9NP,  + +]O\ JJrJcftjjjfd}fd}j s|St j jtjdj}tj|||}|S)aCreate the next layer gather_index whether or not a broadcast happens. *----------bc-------->* | | original_rp broadcast_rp | | \|/ \|/ *--next_broadcaster-->* Args: bc: the old broadcaster. original_rp: the original row partition. broadcast_rp: the target row partition. Returns: the gather_index for next_broadcaster. Raises: InvalidArgumentError if the shapes are incompatible. cNtjj}tjjj}j}t j ||d}|jz}tj|g|S)N)paramsindicesr&rp) rrrrrrrr?rr) rBexpected_row_lengthsactual_row_lengthsrgrrrrArs r=gi_no_broadcastz1_next_layer_gather_index..gi_no_broadcast s%%k&<&<&>&68N$++&&("//C%113((0:LNK!L$@$@$BBL  - -{m\ JJrJcSr?rg)rAsr= gi_broadcastz._next_layer_gather_index..gi_broadcast s  rJr@r) rrrr>rrr'r)r rr&r)rrrrrrrrAs``` @r=rr s(%%boo&2&?&?&AC K     !   > > @ + 4 4Q 8I8I JL,L?D, rJct|tjrtj|j S|j jSr?)rsrrcrrXr1)rs r=rr s5M../ ??2>> **   rJrc D|d}g}|ddD]}t|tr2|}||z}|}|jtj||||E|t |k7r t d|jtj||t|}||fS)a[Allow ragged and uniform shapes to be specified. For example, [2, [2,1], 2] represents a shape like: [[[0, 0], [0, 0]], [[0, 0]]] Args: lengths: a list of integers and lists of integers. dtype: dtype of the shape (tf.int32 or tf.int64) Returns: a sequence of RowPartitions, and the number of values of the last partition. rr@N)rBrnzShape not consistent.)rn) rsrrDrrrrrsum)rr& size_so_farrFcurrent_lengthsrBrCs r=rr s + &  )o/3'e%ek mm  . .uEe EF O, ,011 mm  ' 'E JL(k ) + rJcZ|turyt|trd|zdzSt|S)z"element to a string within a list.z...')rrsrurs r=_element_to_stringr% s-(] 3 7S= Q-rJcH|sydt|dzt|ddzS)z?Print the tail of a list where the list might have an ellipsis.]rLrr@Nr_list_tail_with_ellipsisarrs r=rr. s.  $SV, ,/GAB/P PPrJcH|sydt|dzt|ddzS)z&Print a list that might have ellipsis.z[][rr@Nrrs r=rr6 s.  !#a&) ),DSW,M MMrJczt|tryt|tsy|D]}t|tryy)NTF)rsrr|)rrs r=rr= s=3  Au   a a   rJc|dk(r&tj|jg|S|dz }|| dj}|d| j}tj|g|z|S)zGHelper for _alt_inner_shape, used directly in _with_num_row_partitions.r@r'N)r rrcr)rXr&rnew_inner_rank_tail_lengthinner_shape_tailrs r=rrH sq   !3!3!5 6e DD-16678@@B0001>>@)   yk,<tj|dk(ry||zSr\)rr)rrs r=rGrGR s#!!'*a/  W rJc|jtjk(rYtjtj tj|tj tjStj |Sr?)r&r r{rrrrzrs r=rrZ sYWW  ==X]]1fll;J?  % %j 11rJrjr%rrc|d|}||dzd}|||dz}t|g}tj|||gd}|d|} ||dzd} |||dz} tj| j g} | | z| z} || fS)z.Merge the inner shape of a DynamicRaggedShape.Nr@rr)rrrrrrc)rjr%rrrrinternalinternal_value new_internal prefix_static suffix_staticinternal_staticinternal_value_staticnew_internal_statics r=r r q s { #& zA~ '& JN 3(&x01.!!6>6"BK,$[j1-$Z!^_5-&z*q.A/&22##%&(%(== M + ,,rJrp_specr7c|!t|j|jS|jdn|j|z}|jdn|j|z}t|||j|jS)aBatches a RowPartitionSpec. Given a RowPartitionSpec and a batch_size, create a RowPartitionSpec that will be the spec for the concatenation of batch_size RowPartitions. A RowPartition can be considered a transformation from a list of a given length to a list of lists. Assume rp_a is a map from list_a to nlist_a, And rp_b is a map from list_b to nlist_b. concat(rp_a, rp_b) is a transform of concat(list_a, list_b) to concat(nlist_a, nlist_b). If batch_size is None, then have the spec be able to handle an arbitrary number of RowPartitions. Args: rp_spec: a RowPartitionSpec for all the RowPartitions to be concatenated. batch_size: the number of rp_specs to be concatenated. Returns: a batched RowPartitionSpec. Nr(rA)rr)r&rBrC)rr7rBrCs r=r-r- s}, "55W]] LL--'$W]]Z-G%--'$W]]Z-G%    33 MM  rJold_headc|j|dn||jz}t|||j|jS)zBCreates a RowPartitionSpec representing the new dimension created.NrA)rBrr&)rr7rCs r=r+r+ sK>>)% ,6,G   ! NN  rJ old_shapecDtj|d|z}||ddzS)aReturns a copy of old_shape with axis=0 multiplied by batch_size. Only use if this is the inner_shape of a DynamicRaggedShape.Spec with one or more row partitions. Args: old_shape: the original inner_shape. batch_size: the batch size. Returns: a new shape. rr@NrrFrr7head_dims r=r.r. s, , ,Y :Z G( IabM !!rJc4tj|g|zSr?)rr)rr7s r=r5r5 s  ! !:, /) ;;rJcDtj|d|z}||ddzS)z9Unbatch a static_inner_shape when num_row_partitions > 0.rr@Nrrs r=rErE s, , ,Y :j H( IabM !!rJroctj|j||}tjj ||j S)zReturns ones shaped like x.)r&ro)rrQrjrrcr:r$)rXr&ror1s r=rQrQ s@u00DI+  # # ? ?5'' ))rJr?)erbrtypingrrrrrrnumpyrxtensorflow.python.frameworkr r r r r rdrrtensorflow.python.opsrrrrrrtensorflow.python.ops.raggedr*tensorflow.python.ops.ragged.row_partitionrrtensorflow.python.typesrtensorflow.python.utilr tensorflow.python.util.tf_exportrExtensionTypeBatchEncoderrBatchableExtensionTyper0rrrr$dispatch_for_binary_elementwise_apis RaggedOrDenser+dispatch_for_binary_elementwise_assert_apisrrrwrwrvABCrrrrrrrr:rCrXrerhrnrur}rrrrrrrrrrrrrrrGrr~DenseOrRaggedShaper rerr r-r+r.r5rEfloat32rurQrgrJr=rs  BB3.6+<43+1+&2*6CG(+6l%n&N&Nl%r ,-L7>>L7.L7^,?%7?%7?4 >4 n&4:sm FLL !&.v||&<,S=S=l5/5@F>F>R,0^8K\r r#4r;Gr r <*,= =>rj8/ 8/#48/;G8/ 8/ <*,= =>8/v, ,'8, L !,*2<*@, 8L !8,=#> % & '(,^K);K);K&PP0P9A,9OP|$P*23D*EP)*P |\ 9: P&K(K(0K( |\ 9:K(\*$K@6r  eC#./ 0,/45DQNKl44)338D8N8N!-t>? 2\* 2/; 2-""-$00-- -j//1I1IIJ -,,'}1AD "2 $,SM 6F "''" "".":":"&<<#;#;<$'<,8,D,D< "''" "".":":"~~#)")})(5(C(C)rJ