AVh6dZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZedGddej:Zej>dGddej@Z!ejDejFe!ejHjJd#dZ&d#dZ'dZ(dZ)e*Z+d Z,d$d!Z-d$d"Z.y)%zLA class used to partition a sequence into contiguous subsequences ("rows"). N) struct_pb2)composite_tensor) constant_op)dtypes)ops)tensor)tensor_conversion) tensor_shape) tensor_util) type_spec)type_spec_registry) array_ops) check_ops)control_flow_ops)gen_ragged_math_ops)math_ops)segment_id_ops)nested_structure_coder) tf_exportzexperimental.RowPartitionceZdZdZ d*dZe d+dZe d,dZe d,dZe d,dZ e d,dZ e d-d Z ed.d Z d Z ed Zd ZdZdZdZdZdZdZdZedZedZedZdZdZdZdZdZdZ dZ!dZ"d Z#d!Z$d"Z%d#Z&d$Z'd%Z(d&Z)d'Z*d/d(Z+ed)Z,y)0 RowPartitiona2 Partitioning of a sequence of values into contiguous subsequences ("rows"). A `RowPartition` describes how a sequence with `nvals` items should be divided into `nrows` contiguous subsequences ("rows"). For example, a `RowPartition` could be used to partition the vector `[1, 2, 3, 4, 5]` into subsequences `[[1, 2], [3], [], [4, 5]]`. Note that `RowPartition` stores information about how values are partitioned, but does not include the partitioned values themselves. `tf.RaggedTensor` is used to pair a `values` tensor with one or more `RowPartition`s, providing a complete encoding for a ragged tensor (i.e. a tensor with variable-length dimensions). `RowPartition`s may be defined using several different schemes: * `row_lengths`: an integer vector with shape `[nrows]`, which specifies the length of each row. * `row_splits`: an integer vector with shape `[nrows+1]`, specifying the "split points" between each row. * `row_starts`: an integer vector with shape `[nrows]`, which specifies the start offset for each row. Equivalent to `row_splits[:-1]`. * `row_limits`: an integer vector with shape `[nrows]`, which specifies the stop offset for each row. Equivalent to `row_splits[1:]`. * `value_rowids` is an integer vector with shape `[nvals]`, corresponding one-to-one with sequence values, which specifies the row that each value belongs to. If the partition has empty trailing rows, then `nrows` must also be specified. * `uniform_row_length` is an integer scalar, specifying the length of every row. This scheme may only be used if all rows have the same length. For example, the following `RowPartition`s all represent the partitioning of 8 values into 5 sublists as follows: `[[*, *, *, *], [], [*, *, *], [*], []]`. >>> p1 = RowPartition.from_row_lengths([4, 0, 3, 1, 0]) >>> p2 = RowPartition.from_row_splits([0, 4, 4, 7, 8, 8]) >>> p3 = RowPartition.from_row_starts([0, 4, 4, 7, 8], nvals=8) >>> p4 = RowPartition.from_row_limits([4, 4, 7, 8, 8]) >>> p5 = RowPartition.from_value_rowids([0, 0, 0, 0, 2, 2, 2, 3], nrows=5) For more information about each scheme, see the documentation for the its factory method. For additional examples, see the documentation on `tf.RaggedTensor`. ### Precomputed Encodings `RowPartition` always stores at least one encoding of the partitioning, but it can be configured to cache additional encodings as well. This can avoid unnecessary recomputation in eager mode. (In graph mode, optimizations such as common subexpression elimination will typically prevent these unnecessary recomputations.) To check which encodings are precomputed, use `RowPartition.has_precomputed_`. To cache an additional encoding, use `RowPartition.with_precomputed_`. NcR|tur tdt|tjst d|z|j tjtjfvr td|jjd|jdg||_ |||||fD]T}|t|tjs t d|j |j k7sEtd|d|||_||_||_||_||_y) a@Creates a `RowPartition` from the specified encoding tensor(s). This constructor is private -- please use one of the following ops to build `RowPartition`s: * `RowPartition.from_row_lengths` * `RowPartition.from_value_rowids` * `RowPartition.from_row_splits` * `RowPartition.from_row_starts` * `RowPartition.from_row_limits` * `RowPartition.from_uniform_row_length` If row_splits is has a constant value, then all other arguments should have a constant value. Args: row_splits: A 1-D integer tensor with shape `[nrows+1]`. row_lengths: A 1-D integer tensor with shape `[nrows]` value_rowids: A 1-D integer tensor with shape `[nvals]`. nrows: A 1-D integer scalar tensor. uniform_row_length: A scalar tensor. nvals: A scalar tensor. internal: Private key value, required to ensure that this private constructor is *only* called from the factory methods. Raises: TypeError: If a row partitioning tensor has an inappropriate dtype. TypeError: If exactly one row partitioning argument was not specified. ValueError: If a row partitioning tensor has an inappropriate shape. ValueError: If multiple partitioning arguments are specified. ValueError: If nrows is specified but value_rowids is not None. zzRowPartition constructor is private; please use one of the factory methods instead (e.g., RowPartition.from_row_lengths())z2Row-partitioning argument must be a Tensor, got %rz0Row-partitioning argument must be int32 or int64Nz&Cached value must be a Tensor or None.z)Inconsistent dtype for encoding tensors: z vs )_row_partition_factory_key ValueError isinstance tensor_libTensor TypeErrordtyperint32int64shapeassert_has_rank set_shape _row_splits _row_lengths _value_rowids_nrows_uniform_row_length_nvals) self row_splits row_lengths value_rowidsnrowsuniform_row_lengthnvalsinternalrs Z/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/ragged/row_partition.py__init__zRowPartition.__init__vs8P11 : ;; j*"3"3 4 J ! "" fll;; I JJ$$Q'$ !D  e5GO8  &*"3"34BC C \\Z-- -F$XT*78 8 8$D%DDK1DDKc ddlm}t|ts t dt j dd||g5|j|d||}|ytj|}|&tj|dddggd dd z}d}n|jdkDr|dd znd}t j||jd }nt j||jd }tj|}|W|dkrtd |ztj|}|-|jdkDr||dd zk\std||dfz|j j#d |j j#d|rd} t%j&|d | t%j&|d| t%j(|dd | t+|| t%j,|dd|| g} t/j0| |}t3j4|t6j8} t3j4|t6j8} |j;| | | |j} tjdgt3j<| gd }|'| j?|g|j?|d zg||| ||t@cdddS#1swYyxYw)aCreates a `RowPartition` with rows partitioned by `value_rowids`. This `RowPartition` divides a sequence `values` into rows by specifying which row each value should be added to: ```python partitioned_rows = [[] for _ in nrows] for (value, rowid) in zip(values, value_rowids): partitioned_rows[rowid].append(value) ``` Args: value_rowids: A 1-D integer tensor with shape `[nvals]`, which corresponds one-to-one with `values`, and specifies each value's row index. Must be nonnegative, and must be sorted in ascending order. nrows: An integer scalar specifying the number of rows. This should be specified if the `RowPartition` may containing empty training rows. Must be greater than `value_rowids[-1]` (or greater than or equal to zero if `value_rowids` is empty). Defaults to `value_rowids[-1] + 1` (or zero if `value_rowids` is empty). validate: If true, then use assertions to check that the arguments form a valid `RowPartition`. dtype: Optional dtype for the RowPartition. If missing, the type is inferred from the type of `value_rowids`, dtype_hint, or tf.int64. dtype_hint: Optional dtype for the RowPartition, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so dtype_hint can be used as a soft preference. If the conversion to `dtype_hint` is not possible, this argument has no effect. Returns: A `RowPartition`. Raises: ValueError: If `nrows` is incompatible with `value_rowids`. #### Example: >>> print(RowPartition.from_value_rowids( ... value_rowids=[0, 0, 0, 0, 2, 2, 2, 3], ... nrows=4)) tf.RowPartition(row_splits=[0 4 4 7 8]) r) bincount_opsvalidate must have type boolNRowPartitionFromValueRowIdsr/ dtype_hintr axisrr0namezExpected nrows >= 0; got %dzIExpected nrows >= value_rowids[-1] + 1; got nrows=%d, value_rowids[-1]=%dz?Arguments to from_value_rowids do not form a valid RowPartitionmessage) minlength maxlengthr )r-r.r/r0r3)!tensorflow.python.opsr8rboolrr name_scope_convert_row_partitionr constant_valuerconcatsizeconvert_to_tensorr rr#r$r assert_rankassert_non_negative_assert_monotonic_increasing assert_lessrwith_dependenciesrcastrr!bincountcumsumr%r)clsr/r0validater r<r8 const_rowids const_nrowsmsgchecksvalue_rowids_int32 nrows_int32r.r-s r4from_value_rowidszRowPartition.from_value_rowidssh3 h % 4 55 ;%u- /?/// :U0Ll "11,?  ""L$5t#<1EaH1L%+0<0A0AA0E R(1,1+''<--G=%%%e\-?-?I!007  " 1_:[HI I$33LA,  %,*;*;a*?,r"2Q"66(+6 R8H*IJKK((+ kk!!!$   ! !,3 ?  ! !%C 8  ) ),r*:C H (s C  ! !,rs"3UC H  (99&,O $==v||DMM%6k )) "" *$k ##aS(//+*F$GaPj  {m,kAo./ !#- /u?/?/?/s J,K11K:cTt|ts tdt|ttfr |s t dt|t jr||tStjdd|g5|j|d||}|jjd|rUd }tj|d|d z t!|d |d z t#||dz g}t%j&||}||tcdddS#1swYyxYw)aCreates a `RowPartition` with rows partitioned by `row_splits`. This `RowPartition` divides a sequence `values` into rows by indicating where each row begins and ends: ```python partitioned_rows = [] for i in range(len(row_splits) - 1): row_start = row_splits[i] row_end = row_splits[i + 1] partitioned_rows.append(values[row_start:row_end]) ``` Args: row_splits: A 1-D integer tensor with shape `[nrows+1]`. Must not be empty, and must be sorted in ascending order. `row_splits[0]` must be zero. validate: If true, then use assertions to check that the arguments form a valid `RowPartition`. dtype: Optional dtype for the RowPartition. If missing, the type is inferred from the type of `row_splits`, dtype_hint, or tf.int64. dtype_hint: Optional dtype for the RowPartition, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so dtype_hint can be used as a soft preference. If the conversion to `dtype_hint` is not possible, this argument has no effect. Returns: A `RowPartition`. Raises: ValueError: If `row_splits` is an empty list. r9z#row_splits tensor may not be empty.r-r3NRowPartitionFromRowSplitsr-r;rz>Arguments to from_row_splits do not form a valid RaggedTensor:rankrBrzero monotonic)rrGrlisttuplerr TensorSpecrrrHrIr#r$rrN _assert_zerorPrrR)rVr-rWr r<rZr[s r4from_row_splitszRowPartition.from_row_splits;sN h % 4 55*tUm,Z < ==*j334 J1K LL 9J< HM-- lz.Hj&&q) N  ! !*a#, H Av ? (S;%6 9  &77 K J1K LMMMs ?BDD'ct|ts tdtjdd|g5|j |d||}|j jd|rGd}tj|d|tj||g}tj||}tj|}tj d g|gd }|||t" cdddS#1swYyxYw) a Creates a `RowPartition` with rows partitioned by `row_lengths`. This `RowPartition` divides a sequence `values` into rows by indicating the length of each row: ```python partitioned_rows = [[values.pop(0) for _ in range(length)] for length in row_lengths] ``` Args: row_lengths: A 1-D integer tensor with shape `[nrows]`. Must be nonnegative. validate: If true, then use assertions to check that the arguments form a valid `RowPartition`. dtype: Optional dtype for the RowPartition. If missing, the type is inferred from the type of `row_lengths`, dtype_hint, or tf.int64. dtype_hint: Optional dtype for the RowPartition, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so dtype_hint can be used as a soft preference. If the conversion to `dtype_hint` is not possible, this argument has no effect. Returns: A `RowPartition`. r9NRowPartitionFromRowLengthsr.r;rz>Arguments to from_row_lengths do not form a valid RowPartitionrBrr>)r-r.r3)rrGrrrHrIr#r$rrNrOrrRrrUrrKr) rVr.rWr r<rZr[ row_limitsr-s r4from_row_lengthszRowPartition.from_row_lengthszsB h % 4 55 :[M J/.. }5/Jk''* N  ! !+q# >  ) )+s C '88M ??;/j##aS*$5A>j !-////s B7C55C>c Vt|ts tdtjdd|g5|j |d||}|j jdtj||j}|rfd}tj|d|t|dd|t||tj|d d||g}t!j"||}t%j&||ggd }|||t( cdddS#1swYyxYw) aCreates a `RowPartition` with rows partitioned by `row_starts`. Equivalent to: `from_row_splits(concat([row_starts, nvals], axis=0))`. Args: row_starts: A 1-D integer tensor with shape `[nrows]`. Must be nonnegative and sorted in ascending order. If `nrows>0`, then `row_starts[0]` must be zero. nvals: A scalar tensor indicating the number of values. validate: If true, then use assertions to check that the arguments form a valid `RowPartition`. dtype: Optional dtype for the RowPartition. If missing, the type is inferred from the type of `row_starts`, dtype_hint, or tf.int64. dtype_hint: Optional dtype for the RowPartition, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so dtype_hint can be used as a soft preference. If the conversion to `dtype_hint` is not possible, this argument has no effect. Returns: A `RowPartition`. r9NRowPartitionFromRowStarts row_startsr;rz=Arguments to from_row_starts do not form a valid RaggedTensorrBr=rr>)r-r2r3)rrGrrrHrIr#r$rrSr rrNrhrPassert_less_equalrrRrrKr) rVrpr2rWr r<rZr[r-s r4from_row_startszRowPartition.from_row_startss: h % 4 55 9J< H6-- lz.Hj&&q)mmE:#3#34e M  ! !*a = BQ 5 (S A  ' ' 23 L   &77 K ##Z%$9Bj Je46%666s C!DD(c4t|ts tdtjdd|g5|j |d||}|j jd|rVd}tj|d|tj|dd|t||g}tj||}tjdg|j }tj"||gd }||t$ cdddS#1swYyxYw) aqCreates a `RowPartition` with rows partitioned by `row_limits`. Equivalent to: `from_row_splits(values, concat([0, row_limits], axis=0))`. Args: row_limits: A 1-D integer tensor with shape `[nrows]`. Must be sorted in ascending order. validate: If true, then use assertions to check that the arguments form a valid `RowPartition`. dtype: Optional dtype for the RowPartition. If missing, the type is inferred from the type of `row_limits`, dtype_hint, or tf.int64. dtype_hint: Optional dtype for the RowPartition, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so dtype_hint can be used as a soft preference. If the conversion to `dtype_hint` is not possible, this argument has no effect. Returns: A `RowPartition`. r9NRowPartitionFromRowLimitsrlr;rz=Arguments to from_row_limits do not form a valid RaggedTensorrBrr>r`)rrGrrrHrIr#r$rrNrOrPrrRrzerosr rKr) rVrlrWr r<rZr[rcr-s r4from_row_limitszRowPartition.from_row_limitss4 h % 4 55 9J< HM-- lz.Hj&&q) M  ! !*a =  ) )*Ra.# F (S A  &77 K __aS*"2"2 3d##T:$6Q?j J1K L!MMMs CDDc t|ts td| | tdt j dd||g5t |df|df|dfg||\}}}|jjd tj|}|h|:tj|tjd |j}||z}n,|d k(r"tjd |j }n||z}|dntj|} |dntj|} tj|} g} | R| P| N| | z} |'|r%| j!t#j$|| tj| |j}|||z}| A|?t'| d zD cgc]} | |z }} tj||j}n'tj&|d z|j |z}|r| || 0| j!t#j$||z|d|d |d |fn| |z| k7rtd|| | fz|jj('| j!t#j*|d dtj|}|F| j!t#j,|tjd |jdn|d kr tdt/j0| |}|||||t2cdddScc} w#1swYyxYw)aCreates a `RowPartition` with rows partitioned by `uniform_row_length`. This `RowPartition` divides a sequence `values` into rows that all have the same length: ```python partitioned_rows = [[values.pop(0) for _ in range(uniform_row_length)] for _ in range(nrows)] ``` Note that either or both of nvals and nrows must be specified. Args: uniform_row_length: A scalar integer tensor. Must be nonnegative. The size of the outer axis of `values` must be evenly divisible by `uniform_row_length`. nvals: a non-negative scalar integer tensor for the number of values. Must be specified if nrows is not specified. If not specified, defaults to uniform_row_length*nrows nrows: The number of rows in the constructed RowPartition. If not specified, then it defaults to `nvals/uniform_row_length` (or `0` if `uniform_row_length==0`). `nrows` only needs to be specified if `uniform_row_length` might be zero. `uniform_row_length*nrows` must be `nvals`. validate: If true, then use assertions to check that the arguments form a valid `RowPartition`. dtype: Optional dtype for the RowPartition. If missing, the type is inferred from the type of `uniform_row_length`, dtype_hint, or tf.int64. dtype_hint: Optional dtype for the RowPartition, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so dtype_hint can be used as a soft preference. If the conversion to `dtype_hint` is not possible, this argument has no effect. Returns: A `RowPartition`. r9Nz5Either (or both) of nvals and nrows must be specified RowPartitionFromUniformRowLengthr1r2r0)r r<rrr z times nrowszmust equal nvalsz8uniform_row_length=%d times nrows=%d must equal nvals=%dz$uniform_row_length must be a scalar.rBz uniform_row_length must be >= 0.)r-r1r0r2r3)rrGrrrrH_convert_all_to_tensorsr#r$r rJrmaximumrconstantr appendr assert_equalrangerbrNassert_greater_equalrrRr)rVr1r2r0rWr r<const_row_length rowlen_or_1rY const_nvalsconst_uniform_row_lengthr[vr-s r4from_uniform_row_lengthz$RowPartition.from_uniform_row_lengths\ h % 4 55 } N OO @+U3 5V/ "$68L#M$)7#3eW5E#G(--7 95% ..q1%334FG   # (( ""1&8&>&>?A+;&%  "&&q0B0H0HI%++%!MD{/I/I%/Pk!MD{/I/I%/Pk!,!;!; >  # # ( ( 0 --##$@B C '556HI  # --,,$&&q*<*B*BC<> ?  !?@ @%77 K /- /cV/V/PLQV/V/s E.L92 L4>E,L94L99Mcr|tj}t|tjr7|j tj k(r|tj||}ntj||||}|j tj tjfvrtd|z|S)aConverts `partition` to Tensors. Args: partition: A row-partitioning tensor for the `RowPartition` being constructed. I.e., one of: row_splits, row_lengths, row_starts, row_limits, value_rowids, uniform_row_length. name: The name of the row-partitioning tensor. dtype: Optional dtype for the RowPartition. If missing, the type is inferred from the type of `uniform_row_length`, dtype_hint, or tf.int64. dtype_hint: Optional dtype for the RowPartition, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so dtype_hint can be used as a soft preference. If the conversion to `dtype_hint` is not possible, this argument has no effect. Returns: A tensor equivalent to partition. Raises: ValueError: if dtype is not int32 or int64. r@)r<r rAz!%s must have dtype int32 or int64) rr"rnpndarrayr r!rrMr convert_to_tensor_v2r)rV partitionrAr r<s r4rIz#RowPartition._convert_row_partitions0<.>.D.DaHG}} __T-- CA F JJ  ! !'--!"34:: FFr6c|jS)a-Returns the length of each row in this partition, if rows are uniform. If all rows in this `RowPartition` have the same length, then this returns that length as a scalar integer `Tensor`. Otherwise, it returns `None`. Returns: scalar Tensor with `type=self.dtype`, or `None`. r*rs r4r1zRowPartition.uniform_row_lengths  # ##r6c |jddS)aReturns the start indices for rows in this row partition. These indices specify where the values for each row begin. `partition.row_starts()` is equal to `partition.row_splits()[:-1]`. Returns: A 1-D integer Tensor with shape `[self.nrows()]`. The returned tensor is nonnegative, and is sorted in ascending order. `self.row_starts()[0] == 0`. `self.row_starts()[-1] <= self.nvals()`. Nr=rrs r4rpzRowPartition.row_starts's   CR  r6c |jddS)aReturns the limit indices for rows in this row partition. These indices specify where the values for each row end. `partition.row_limits()` is equal to `partition.row_splits()[:-1]`. Returns: A 1-D integer Tensor with shape `[self.nrows]`. The returned tensor is nonnegative, and is sorted in ascending order. `self.row_limits()[-1] == self.nvals()`. rNrrs r4rlzRowPartition.row_limits5s   AB r6c`|j |jS|j}|dd|ddz S)zReturns the lengths of rows in this `RowPartition`. Returns: A 1-D integer Tensor with shape `[self.nrows]`. The returned tensor is nonnegative. `tf.reduce_sum(self.row_lengths) == self.nvals()`. Nrr=)r'r&)r,splitss r4r.zRowPartition.row_lengthsBs> $      F !":s ##r6cP|j3tj|jjd}||dz S|j0tj|jjd}||S|j t j|j Sy)aThe number of rows in this partition, if statically known. ```python self.row_lengths().shape == [self.static_nrows] self.row_starts().shape == [self.static_nrows] self.row_limits().shape == [self.static_nrows] self.row_splits().shape == [self.static_nrows + 1] ``` Returns: The number of rows in this partition as an `int` (if statically known); or `None` (otherwise). Nrr)r&r dimension_valuer#r'r)r rJ)r,nrows_plus_oner0s r4 static_nrowszRowPartition.static_nrowsOs ##33D4D4D4J4J14MNn  #!! $**4+<+<+B+B1+EFe    {{  ' ' 44 r6c|j#tj|j}||S|jBt j |jj d}|j |jSy)aThe number of values in this partition, if statically known. ```python self.value_rowids().shape == [self.static_vals] ``` Returns: The number of values in this partition as an `int` (if statically known); or `None` (otherwise). Nr)r+r rJr(r rr#r)r,r2s r4 static_nvalszRowPartition.static_nvalsjsn {{((5e    %--d.@.@.F.FJe  {{ r6cZ|jtj|jSy)zThe number of values in each row of this partition, if statically known. Returns: The number of values in each row of this partition as an `int` (if statically known); or `None` (otherwise). N)r*r rJrs r4static_uniform_row_lengthz&RowPartition.static_uniform_row_lengths* +  ' '(@(@ AA r6ctjtjd|j|j tjd|jj S)a%Return the offset of each value. RowPartition takes an array x and converts it into sublists. offsets[i] is the index of x[i] in its sublist. Given a shape, such as: [*,*,*],[*,*],[],[*,*] This returns: 0,1,2,0,1,0,1 Returns: an offset for every value. rr)startslimitsdeltas)r ragged_rangerr|r r.rt_dense_valuesrs r4offsets_in_rowszRowPartition.offsets_in_rowssT  + +##Atzz2!##Atzz2 45DODr6c|jduS)aReturns true if the partition is known to be uniform statically. This is based upon the existence of self._uniform_row_length. For example: RowPartition.from_row_lengths([3,3,3]).is_uniform()==false RowPartition.from_uniform_row_length(5, nvals=20).is_uniform()==true RowPartition.from_row_lengths([2,0,2]).is_uniform()==false Returns: Whether a RowPartition is known to be uniform statically. Nrrs r4 is_uniformzRowPartition.is_uniforms  # #4 //r6c|j}|jS|jj|k7r:tdt|jjzdzt|z|jS|jj|k7r:tdt|jjzdzt|z|j S|j j|k7r:tdt|j jzdzt|z|j T|j j|k7r:tdt|j jzdzt|zyy)zbChecks if the object is internally consistent. Raises: ValueError if inconsistent. Nz_uniform_row_length.dtype=z, not z_row_lengths.dtype=z_value_rowids.dtype=z _nrows.dtype=)r r*rstrr'r(r))r,my_dtypes r4 _static_checkzRowPartition._static_checks{ zzH + ! ! ' '8 35T55;;<=?GHX'( ( $):):)@)@H)L ,s43D3D3J3J/KK "%h-0 11 %$*<*<*B*Bh*N -D4F4F4L4L0MM "%h-0 11 {{4;;#4#4#@ T[[->->)??(J8}% &&$Ar6c tj|}|tjtjfvr t d|j |k(r|St t|j|t|j|t|j|t|j|t|j|tS)a1Returns a copy of this RowPartition with the given encoding dtype. Args: dtype: The dtype for encoding tensors, such as `row_splits` and `nrows`. One of `tf.int32` or `tf.int64`. Returns: A copy of this RowPartition, with the encoding tensors cast to the given type. zdtype must be int32 or int64r)ras_dtyper!r"rr r_cast_if_not_noner&r'r(r)r*r)r,r s r4 with_dtypezRowPartition.with_dtypes OOE "E V\\6<<00 5 66 zzU k $T%5%5u=%d&7&7?&t'9'95A U3,T-E-EuM+  --r6ct|jd|jd|jdSd|jdS)Nztf.RowPartition(nrows=, uniform_row_length=)ztf.RowPartition(row_splits=)r*r)r&rs r4__repr__zRowPartition.__repr__sP +&t{{m4$$($<$<#=Q@A+4+;+;*>r6c|jduS)zReturns true if `row_splits` has already been computed. If true, then `self.row_splits()` will return its value without calling any TensorFlow ops. Nrrs r4_has_precomputed_row_splitsz(RowPartition._has_precomputed_row_splitss   4 ''r6c|jduS)zReturns true if `row_lengths` has already been computed. If true, then `self.row_lengths()` will return its value without calling any TensorFlow ops. N)r'rs r4_has_precomputed_row_lengthsz)RowPartition._has_precomputed_row_lengthss   D ((r6c|jduS)zReturns true if `value_rowids` has already been computed. If true, then `self.value_rowids()` will return its value without calling any TensorFlow ops. N)r(rs r4_has_precomputed_value_rowidsz*RowPartition._has_precomputed_value_rowidss   T ))r6c|jduS)zReturns true if `nrows` has already been computed. If true, then `self.nrows()` will return its value without calling any TensorFlow ops. N)r)rs r4_has_precomputed_nrowsz#RowPartition._has_precomputed_nrows ;;d ""r6c|jduS)zReturns true if `nvals` has already been computed. If true, then `self.nvals()` will return its value without calling any TensorFlow ops. N)r+rs r4_has_precomputed_nvalsz#RowPartition._has_precomputed_nvalsrr6c t|j|j|j|j|j |j tS)7Returns a copy of `self` with `row_splits` precomputed.r-r.r/r0r1r2r3)rr-r'r(r)r*r+rrs r4_with_precomputed_row_splitsz)RowPartition._with_precomputed_row_splitssE ??$%%''kk33kk+ --r6c t|j|j|j|j|j |j tS)z8Returns a copy of `self` with `row_lengths` precomputed.r-r.r/r0r2r1r3)rr&r.r(r)r+r*rrs r4_with_precomputed_row_lengthsz*RowPartition._with_precomputed_row_lengths#sG ##$$&''kkkk33+ --r6c t|j|j|j|j|j |j tS)z9Returns a copy of `self` with `value_rowids` precomputed.r)rr&r'r/r)r+r*rrs r4_with_precomputed_value_rowidsz+RowPartition._with_precomputed_value_rowids.sG ##%%&&(kkkk33+ --r6c t|j|j|j|j |j |j tS)z2Returns a copy of `self` with `nrows` precomputed.r)rr&r'r(r0r+r*rrs r4_with_precomputed_nrowsz$RowPartition._with_precomputed_nrows9sF ##%%''jjlkk33+ --r6c t|j|j|j|j|j |j tS)rr)rr-r'r(r)r2r*rrs r4_with_precomputed_nvalsz$RowPartition._with_precomputed_nvalsDsG ??$%%''kkjjl33+ --r6c F|j}|j|s td|j*t j |j|j n |j}|j*t j |j|j n |j}|j*t j |j|j n |j}t|j|j|j|||t S)z3Merge with a TypeSpec to create a new RowPartition.z4RowPartition and RowPartitionSpec are not compatible)r-r.r/r2r1r0r3) _type_specis_compatible_withrr0rr|r r)r2r+r1r*rr&r'r(r)r,ba_specr0r2r1s r4_merge_with_speczRowPartition._merge_with_specOs __F  $ $Q ' M NN ! 3    9= !" 3    9=    )%-- djj/3/G/G ##%%''-+ --r6c ^||us|j|jurz|j|jurb|j|jurJ|j|jur2|j|jur|j |j ur|St |j|jd|\}}t |j|jd|\}}t |j |j d|\}}|r|rd}t |j|jd|\} } | rd}t |j|jd|\} } | rd}t |j|jd|\} }|r|rd}| |jur:| |jur,| |jur||jur||j ur|S| |jur:| |jur,| |jur||jur||j ur|St| | | |||tS) aReturns a RowPartition that merges encodings from `self` and `other`. Requires that `self` and `other` describe the same partition. Args: other: A `RowPartition` that encodes the same partition as `self`. validate: If true, then add runtime checks to verify that `self` and `other` encode the same row partition. Returns: A `RowPartition`. r0r2r1Fr-r.r/r) r&r'r(r)r+r*_merge_tensorsrr)r,otherrWr0nrows_validatedr2_r1uniform_row_length_validatedr-row_splits_validatedr.row_lengths_validatedr/value_rowids_validateds r4_merge_precomputed_encodingsz)RowPartition._merge_precomputed_encodingses6   U.. .  e00 0  u22 2  $  $ ! !U%>%> > k,DKKw,46E?dkk5<<(KHE17E   %";";h8(44$h'5d6F6F6;6G6G6BH(N$J$h)78I8I8=8J8J8Ex*Q&K&h+9 E//,K(L(/h d&&&;$:K:K+K***u /Cd666 ke'''u)))+++0Ee777 l !-+ --r6c,tj|SN)RowPartitionSpec from_valuers r4rzRowPartition._type_specs  & &t ,,r6)NNNNNF)NTNN)TNN)NNTNNNN)T)-__name__ __module__ __qualname____doc__r5 classmethodr^rirmrrrvrrIrpropertyr r-r/r2r0r1rprlr.rrrrrrrrrrrrrrrrrrrrrr6r4rr8s7|  "&GZ#!%"#' u/u/n $ !% <M<M|!%!"& 4/4/l $ !% 1616f $ !% +M+MZ%)$('+$()- G/G/R##J-4 " "  F   G $ !   $  4  *    D$ 0&:-:?()*## - - - - --,F-X - -r6rztf.RowPartitionSpecc eZdZdZgdZedZdddejfdZ fdZ dZ e dZ ed Zed Zed Zed Zed ZdZdZe dZdZedZdZdZdZxZS)rz+Type specification for a `tf.RowPartition`.r)r+r*_dtypectSr)rrs r4zRowPartitionSpec.s\r6Nc:tj|g}tj|g}t|tjstj|g}n|jd}||_||_||_tj||_ |jtjtjfvr tdtj|d}tj|d}tj|d}|dk(r4|tjdg|_n|dk7rtd|d||dk(r4|tjdg|_n|dk7rtd|d||d|b|dk7r||zdk7rtd|d|d||||zk7rtd|d|d ||#|dk7rtj||zg|_|%|"|tj||zg|_yyyy) aConstructs a new RowPartitionSpec. Args: nrows: The number of rows in the RowPartition, or `None` if unspecified. nvals: The number of values partitioned by the RowPartition, or `None` if unspecified. uniform_row_length: The number of values in each row for this RowPartition, or `None` if rows are ragged or row length is unspecified. dtype: The data type used to encode the partition. One of `tf.int64` or `tf.int32`. rz"dtype must be tf.int32 or tf.int64rNznvals=z is not compatible with nrows=z+ is not compatible with uniform_row_length=z (doesn't divide evenly)z and uniform_row_length=)r TensorShaper with_rankr)r+r*rrrr!r"rr)r,r0r2r1r ncolss r4r5zRowPartitionSpec.__init__s"$  $ $eW -E  $ $eW -E (,*B*B C'335G4HI-77:DKDK1D//%(DK {{6<<66 ; <<  ( (q 2E  ( (q 2E  ( ();A)> ?E z "..s3 A:() ) z "..s3 A:"');=> > U. ! *:?HI I  u 5495%IJ J 5A:"../?@  U.5= ,,eem_=dk4A.r6c0tt| |sy|jj |j }|j j |j}|jj |j}|j|||S)NF) superrrr) merge_withr0r+r2r*r1_dimensions_compatible)r,rr0r2r __class__s r4rz#RowPartitionSpec.is_compatible_withsw !4 ;E B  KK " "5;; /E KK " "5;; /E  $ $ / /0H0H IE  & &ueU ;;r6c^|j|j|j|jfSrrrs r4 _serializezRowPartitionSpec._serialize s# KKd&>&> LLr6c|\}}}}tj|d}tj|d}|||||SNrr r)rV serializationr0r2r1r s r4 _deserializezRowPartitionSpec._deserialize sM1>-UE%u  ( (q 2E  ( (q 2E ue/ 77r6cFtj|jdSr)r rr)rs r4r0zRowPartitionSpec.nrows  ' ' A 77r6cFtj|jdSr)r rr+rs r4r2zRowPartitionSpec.nvalsr r6cFtj|jdSr)r rr*rs r4r1z#RowPartitionSpec.uniform_row_lengths  ' '(@(@(C DDr6c|jSr)rrs r4r zRowPartitionSpec.dtype s ;;r6ctjtj|jddzg}t j ||j S)Nrr)r rrr)rrgr)r,row_splits_shapes r4_component_specsz!RowPartitionSpec._component_specs$sG#//  ( (a 81 <=?  !14;; ??r6c"|jSr)r-)r,rs r4_to_componentszRowPartitionSpec._to_components*s    r6c0tj|dS)NF)rW)rri)r,rs r4_from_componentsz!RowPartitionSpec._from_components-s  ' ' ' ??r6ct|ts td||j|j|j |j S)Nz'Expected `value` to be a `RowPartition`)rrrrrrr )rVrs r4rzRowPartitionSpec.from_value0sD e\ * ? @@ u!!5#5#5..  ==r6c pd|jd|jd|jd|jd S)NzRowPartitionSpec(nrows=z, nvals=rz, dtype=rr0r2r1r rs r4rzRowPartitionSpec.__repr__7s(::tzz43J3J:: '(r6ctj|d}tj|d}tj|d}|dk(r|dvry|dk(r|dvry|||dk7r ||zdk7ry| |||zk7ryy)z4Returns true if the given dimensions are compatible.r)rNFTr)r0r2r1rs r4rz'RowPartitionSpec._dimensions_compatible<s  ( (q 2E  ( (q 2E  ( ();A)> ?E ze9,  ze9,  U. ! *  u 5 r6c|jj|j}|jj|j}|j j|j }tj|||s td|j|jk7r tdt|d|d|d|jS)zMerge two RowPartitionSpecs.z&Merging incompatible RowPartitionSpecsz2Merging RowPartitionSpecs with incompatible dtypesrr) r)rr0r+r2r*r1rrrr )r,rr0r2rs r4 _merge_withzRowPartitionSpec._merge_withMs KK " "5;; /E KK " "5;; /E  $ $ / /0H0H IE  2 25% G ? @@ zzU[[ K LL %("'(/4Qx"&** ..r6ctj|jd}tj|jd}t |||j |Sr)r rr)r+rr*)r,r r0r2s r4rzRowPartitionSpec.with_dtype_sI  ( (Q 8E  ( (Q 8E E5$*B*BE JJr6c ~|j}tj|jd}tj|jd}|j dn!tj|j d}t ||||Sr)r r rr)r+r*r)r,memor r0r2r1s r4 __deepcopy__zRowPartitionSpec.__deepcopy__ds JJE  ( (Q 8E  ( (Q 8E"&":":"B$&66"66q9; E5*x<M88 8 8 8 8 E E   @ @ @== (  .$K Er6rcBtj|dd|ddz |S)Nrr=rB)rrOrrCs r4rPrP{s+  & & QRj6#2; 11r6cptj|tjd|j|S)NrryrB)rr~rr|r r$s r4rhrhs/    k""1FLL97 LLr6c6|dStj||Sr)rrS)rr s r4rrsAX]]65%AAr6c||dfS||dfS||ur|dfSd|z}|jj|js t||r1tj|||g}t j ||dfS|dfS)aMerge two optional Tensors with equal values into a single Tensor. Args: t1: tf.Tensor or None t2: tf.Tensor or None name: A name for the tensors (for error messages) validate: If true, then check that `t1` is compatible with `t2` (if both are non-None). Returns: A pair `(merged_value, validated)`: * `merged_value` is `t1` if it is not None; or `t2` otherwise. * `validated` is true if we validated that t1 and t2 are equal (either by adding a check, or because t1 is t2). FTzJRowPartition._merge_precomputed_encodings: partitions have incompatible %srB)r#rrrr~rrR)t1t2rArWerr_msgr[s r4rrs Z u9 z u9 Rx t8O&(,-G 88 & &rxx 0 w &&r2w?@f  / / ;T AA Yr6cPt|tjr |jSyr)rrrr )rs r4_get_dtype_or_noner,sz(() ;; r6c||S|D]*}t|tjs|jcS|D]=}t|tj st j|jcS||St jS)z,Gets the target dtype of a family of values.) rrrr rrrrr")valuesr r<rs r4_get_target_dtyper/s  Le%**+ [[*e%$ __U[[ ))*  r6c .t|Dcgc]\}}| c}}||}|du}|r/|Dcgc]!\}}|dntj|||#c}}S|Dcgc]!\}}|dntj|||#c}}Scc}}wcc}}wcc}}w)z7Convert a list of objects to tensors of the same dtype.N)r rA)r/rrMrrS)r.r r<xr target_dtypeconvert_behaviorrAs r4rzrzs"F#;&1aA#;UJO,d]@F 2;1d s44 \ . .    Q x}}QlNN $<   s B &B &Brr)/rnumpyrtensorflow.core.protobufrtensorflow.python.frameworkrrrrrrr r r r r rFrrrrrtensorflow.python.ops.raggedrtensorflow.python.saved_modelr tensorflow.python.util.tf_exportrCompositeTensorrregisterTypeSpecrregister_codecBuiltInTypeSpecCodec TypeSpecProtoROW_PARTITION_SPECrPrhrrobjectrr,r/rzrr6r4rBs/83.+<9431:++25*7@6 &'z-#33z-(z-H$23nEy))nE4nEb&%%///*22EE1 L BB$X &r6