AVh dZddlZddlZddlmZddlmZddlmZddlmZddlmZddl m Z dd l m Z dd l m Z dd l m Z dd lmZdd lmZddlmZddlmZedddgGddej*ddgZedGddej*dgdZedddgGddej*dgdZedddgGddej*dgd Zed!d!d"gGd#d"ej*d"gd$ZGd%d&Zd'Zd(Z d+d)Z d+d*Zy),z.Feature configuration for tf.io.parse_example.N) constant_op)dtypes)ops)tensor) tensor_shape) array_ops) check_ops)math_ops) sparse_ops)ragged_math_ops) ragged_tensor) tf_logging) tf_exportzio.VarLenFeature VarLenFeature)v1ceZdZdZy)rzgConfiguration for parsing a variable-length input feature. Fields: dtype: Data type of input. N)__name__ __module__ __qualname____doc__T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/parsing_config.pyrr,s  rdtypezio.RaggedFeaturec@eZdZdZej ddgZej ddgZej ddgZej ddgZ ej ddgZ ej dd gZ eeee e e fZ d d e jd ffd ZxZS) RaggedFeatureaConfiguration for passing a RaggedTensor input feature. `value_key` specifies the feature key for a variable-length list of values; and `partitions` specifies zero or more feature keys for partitioning those values into higher dimensions. Each element of `partitions` must be one of the following: * `tf.io.RaggedFeature.RowSplits(key: string)` * `tf.io.RaggedFeature.RowLengths(key: string)` * `tf.io.RaggedFeature.RowStarts(key: string)` * `tf.io.RaggedFeature.RowLimits(key: string)` * `tf.io.RaggedFeature.ValueRowIds(key: string)` * `tf.io.RaggedFeature.UniformRowLength(length: int)`. Where `key` is a feature key whose values are used to partition the values. Partitions are listed from outermost to innermost. * If `len(partitions) == 0` (the default), then: * A feature from a single `tf.Example` is parsed into a 1D `tf.Tensor`. * A feature from a batch of `tf.Example`s is parsed into a 2D `tf.RaggedTensor`, where the outer dimension is the batch dimension, and the inner (ragged) dimension is the feature length in each example. * If `len(partitions) == 1`, then: * A feature from a single `tf.Example` is parsed into a 2D `tf.RaggedTensor`, where the values taken from the `value_key` are separated into rows using the partition key. * A feature from a batch of `tf.Example`s is parsed into a 3D `tf.RaggedTensor`, where the outer dimension is the batch dimension, the two inner dimensions are formed by separating the `value_key` values from each example into rows using that example's partition key. * If `len(partitions) > 1`, then: * A feature from a single `tf.Example` is parsed into a `tf.RaggedTensor` whose rank is `len(partitions)+1`, and whose ragged_rank is `len(partitions)`. * A feature from a batch of `tf.Example`s is parsed into a `tf.RaggedTensor` whose rank is `len(partitions)+2` and whose ragged_rank is `len(partitions)+1`, where the outer dimension is the batch dimension. There is one exception: if the final (i.e., innermost) element(s) of `partitions` are `UniformRowLength`s, then the values are simply reshaped (as a higher-dimensional `tf.Tensor`), rather than being wrapped in a `tf.RaggedTensor`. #### Examples >>> import google.protobuf.text_format as pbtext >>> example_batch = [ ... pbtext.Merge(r''' ... features { ... feature {key: "v" value {int64_list {value: [3, 1, 4, 1, 5, 9]}}} ... feature {key: "s1" value {int64_list {value: [0, 2, 3, 3, 6]}}} ... feature {key: "s2" value {int64_list {value: [0, 2, 3, 4]}}} ... }''', tf.train.Example()).SerializeToString(), ... pbtext.Merge(r''' ... features { ... feature {key: "v" value {int64_list {value: [2, 7, 1, 8, 2, 8, 1]}}} ... feature {key: "s1" value {int64_list {value: [0, 3, 4, 5, 7]}}} ... feature {key: "s2" value {int64_list {value: [0, 1, 1, 4]}}} ... }''', tf.train.Example()).SerializeToString()] >>> features = { ... # Zero partitions: returns 1D tf.Tensor for each Example. ... 'f1': tf.io.RaggedFeature(value_key="v", dtype=tf.int64), ... # One partition: returns 2D tf.RaggedTensor for each Example. ... 'f2': tf.io.RaggedFeature(value_key="v", dtype=tf.int64, partitions=[ ... tf.io.RaggedFeature.RowSplits("s1")]), ... # Two partitions: returns 3D tf.RaggedTensor for each Example. ... 'f3': tf.io.RaggedFeature(value_key="v", dtype=tf.int64, partitions=[ ... tf.io.RaggedFeature.RowSplits("s2"), ... tf.io.RaggedFeature.RowSplits("s1")]) ... } >>> feature_dict = tf.io.parse_single_example(example_batch[0], features) >>> for (name, val) in sorted(feature_dict.items()): ... print('%s: %s' % (name, val)) f1: tf.Tensor([3 1 4 1 5 9], shape=(6,), dtype=int64) f2: f3: >>> feature_dict = tf.io.parse_example(example_batch, features) >>> for (name, val) in sorted(feature_dict.items()): ... print('%s: %s' % (name, val)) f1: f2: f3: Fields: dtype: Data type of the `RaggedTensor`. Must be one of: `tf.dtypes.int64`, `tf.dtypes.float32`, `tf.dtypes.string`. value_key: (Optional.) Key for a `Feature` in the input `Example`, whose parsed `Tensor` will be the resulting `RaggedTensor.flat_values`. If not specified, then it defaults to the key for this `RaggedFeature`. partitions: (Optional.) A list of objects specifying the row-partitioning tensors (from outermost to innermost). Each entry in this list must be one of: * `tf.io.RaggedFeature.RowSplits(key: string)` * `tf.io.RaggedFeature.RowLengths(key: string)` * `tf.io.RaggedFeature.RowStarts(key: string)` * `tf.io.RaggedFeature.RowLimits(key: string)` * `tf.io.RaggedFeature.ValueRowIds(key: string)` * `tf.io.RaggedFeature.UniformRowLength(length: int)`. Where `key` is a key for a `Feature` in the input `Example`, whose parsed `Tensor` will be the resulting row-partitioning tensor. row_splits_dtype: (Optional.) Data type for the row-partitioning tensor(s). One of `int32` or `int64`. Defaults to `int32`. validate: (Optional.) Boolean indicating whether or not to validate that the input values form a valid RaggedTensor. Defaults to `False`. RowSplitskey RowLengths RowStarts RowLimits ValueRowIdsUniformRowLengthlengthNrFc|+t|tstd||s tdtj|}|tj tj tjfvrtd|tj|}|tjtj fvrtd|t|ttfs%td|dt|jd|D]3}t||jrtd|jd |t|tstd |t t"|K||||||S) Nz+Argument `value_key` must be a string; got z&Argument `value_key` must not be emptyz7Argument `dtype` must be int64, float32, or bytes; got z7Argument `row_splits_dtype` must be int32 or int64; gotzBArgument `partitions` must be a list or tuple. Receivedpartitions=z of type .z:Argument `partitions` must be a list of partition objects z; got: z(Argument `validate` must be a bool; got ) isinstancestr ValueErrorras_dtypeint64float32stringint32listtuple TypeErrortyper_PARTITION_TYPESboolsuperr__new__)clsr value_key partitionsrow_splits_dtypevalidate partition __class__s rr6zRaggedFeature.__new__s   3 '9) EG G ABB OOE "E V\\6>>6==AA P$ %%'78 fll;; P*-/ 00 j4- 0 $$.++[++,> K Y ;&( %|| IIrr)rr8r9r:r;zio.SparseFeature SparseFeaturec$eZdZdZdfd ZxZS)rBaZ Configuration for parsing a sparse input feature from an `Example`. Note, preferably use `VarLenFeature` (possibly in combination with a `SequenceExample`) in order to parse out `SparseTensor`s instead of `SparseFeature` due to its simplicity. Closely mimicking the `SparseTensor` that will be obtained by parsing an `Example` with a `SparseFeature` config, a `SparseFeature` contains a * `value_key`: The name of key for a `Feature` in the `Example` whose parsed `Tensor` will be the resulting `SparseTensor.values`. * `index_key`: A list of names - one for each dimension in the resulting `SparseTensor` whose `indices[i][dim]` indicating the position of the `i`-th value in the `dim` dimension will be equal to the `i`-th value in the Feature with key named `index_key[dim]` in the `Example`. * `size`: A list of ints for the resulting `SparseTensor.dense_shape`. For example, we can represent the following 2D `SparseTensor` ```python SparseTensor(indices=[[3, 1], [20, 0]], values=[0.5, -1.0] dense_shape=[100, 3]) ``` with an `Example` input proto ```python features { feature { key: "val" value { float_list { value: [ 0.5, -1.0 ] } } } feature { key: "ix0" value { int64_list { value: [ 3, 20 ] } } } feature { key: "ix1" value { int64_list { value: [ 1, 0 ] } } } } ``` and `SparseFeature` config with 2 `index_key`s ```python SparseFeature(index_key=["ix0", "ix1"], value_key="val", dtype=tf.float32, size=[100, 3]) ``` Fields: index_key: A single string name or a list of string names of index features. For each key the underlying feature's type must be `int64` and its length must always match that of the `value_key` feature. To represent `SparseTensor`s with a `dense_shape` of `rank` higher than 1 a list of length `rank` should be used. value_key: Name of value feature. The underlying feature's type must be `dtype` and its length must always match that of all the `index_key`s' features. dtype: Data type of the `value_key` feature. size: A Python int or list thereof specifying the dense shape. Should be a list if and only if `index_key` is a list. In that case the list must be equal to the length of `index_key`. Each for each entry `i` all values in the `index_key`[i] feature must be in `[0, size[i])`. already_sorted: A Python boolean to specify whether the values in `value_key` are already sorted by their index position. If so skip sorting. False by default (optional). c4tt| ||||||SN)r5rBr6)r7 index_keyr8rsizealready_sortedr=s rr6zSparseFeature.__new__%s&  , Y 5$ @@r)Frrrrr6r@rAs@rrBrBs ?B@@r)rFr8rrGrHzio.FixedLenFeatureFixedLenFeaturec$eZdZdZdfd ZxZS)rJaConfiguration for parsing a fixed-length input feature. To treat sparse input as dense, provide a `default_value`; otherwise, the parse functions will fail on any examples missing this feature. Fields: shape: Shape of input data. dtype: Data type of input. default_value: Value to be used if an example is missing this feature. It must be compatible with `dtype` and of the specified `shape`. c0tt| ||||SrE)r5rJr6)r7shaper default_valuer=s rr6zFixedLenFeature.__new__9s # . UE= **rrErIrAs@rrJrJ*s **r)rMrrNzio.FixedLenSequenceFeatureFixedLenSequenceFeaturec$eZdZdZdfd ZxZS)rOaConfiguration for parsing a variable-length input feature into a `Tensor`. The resulting `Tensor` of parsing a single `SequenceExample` or `Example` has a static `shape` of `[None] + shape` and the specified `dtype`. The resulting `Tensor` of parsing a `batch_size` many `Example`s has a static `shape` of `[batch_size, None] + shape` and the specified `dtype`. The entries in the `batch` from different `Examples` will be padded with `default_value` to the maximum length present in the `batch`. To treat a sparse input as dense, provide `allow_missing=True`; otherwise, the parse functions will fail on any examples missing this feature. Fields: shape: Shape of input data for dimension 2 and higher. First dimension is of variable length `None`. dtype: Data type of input. allow_missing: Whether to allow this feature to be missing from a feature list item. Is available only for parsing `SequenceExample` not for parsing `Examples`. default_value: Scalar value to be used to pad multiple `Example`s to their maximum length. Irrelevant for parsing a single `Example` or `SequenceExample`. Defaults to "" for dtype string and 0 otherwise (optional). c2tt| |||||SrE)r5rOr6)r7rMr allow_missingrNr=s rr6zFixedLenSequenceFeature.__new__\s# (# 6 UE=- 99r)FNrIrAs@rrOrO>s 299r)rMrrRrNceZdZdZ ddZedZedZedZ edZ dZ d Z d Z d Zd Zd ZdZdZdZdZy)_ParseOpParamsaRaw parameters used by `gen_parsing_ops`. Attributes: sparse_keys: A list of string keys in the examples' features. The results for these keys will be returned as `SparseTensor` objects. sparse_types: A list of `DTypes` of the same length as `sparse_keys`. Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`), and `tf.string` (`BytesList`) are supported. dense_keys: A list of string keys in the examples' features. The results for these keys will be returned as `Tensor`s dense_types: A list of DTypes of the same length as `dense_keys`. Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`), and `tf.string` (`BytesList`) are supported. dense_defaults: A dict mapping string keys to `Tensor`s. The keys of the dict must match the dense_keys of the feature. dense_shapes: A list of tuples with the same length as `dense_keys`. The shape of the data for each dense feature referenced by `dense_keys`. Required for any input tensors identified by `dense_keys`. Must be either fully defined, or may contain an unknown first dimension. An unknown first dimension means the feature is treated as having a variable number of blocks, and the output shape along this dimension is considered unknown at graph build time. Padding is applied for minibatch elements smaller than the maximum number of blocks for the given feature along this dimension. ragged_keys: A list of string keys in the examples' features. The results for these keys will be returned as `RaggedTensor` objects. ragged_value_types: A list of `DTypes` of the same length as `ragged_keys`, specifying the value type for each ragged feature. Must be one of: `tf.float32`, `tf.int64`, `tf.string`. ragged_split_types: A list of `DTypes` of the same length as `ragged_keys`, specifying the row_splits type for each ragged feature. Must be one of: `tf.int32`, `tf.int64`. dense_shapes_as_proto: dense_shapes converted to TensorShapeProto. dense_defaults_vec: A vector of `Tensor`s containing the default values, corresponding 1:1 with `dense_keys`. num_features: The total number of feature keys. Nc |tjn|}|gn|}|gn|}|gn|}|gn|}|ggt|zn|}|gn|}|gn|}| gn| } ||_|D cgc]} t j | c} |_||_|D cgc]} t j | c} |_|D cgc]} tj| c} |_ ||_ ||_ |D cgc]} t j | c} |_| D cgc]} t j | c} |_|j!ycc} wcc} wcc} wcc} wcc} wrE)r> OrderedDictlen sparse_keysrr* sparse_types dense_keys dense_typesras_shape dense_shapesdense_defaults ragged_keysragged_value_typesragged_split_types _validate) selfrXrYrZr[r^r]r_r`ratss r__init__z_ParseOpParams.__init__sm&4%; !#+"K%-2N>N:O OOrc t|j|j|jDcgc]\}}}|j |||c}}}Scc}}}wrE)ziprZr]r[_make_dense_default)rckrerds rdense_defaults_vecz!_ParseOpParams.dense_defaults_vecsW4??D,=,=t?O?OP   Aq!   Aq)  sAc|jj|}|j|jdkDr|jdjz|.t j |tjk(rdnd|}|Sdtjdd|z}t j |||}tj|g}|S|tjg|}|St|t j"sHdtjdd|z}t j |||}tj||}|S) zConstruct the default value tensor for a specified dense feature. Args: key: The key string identifying the dense feature. shape: The dense feature's shape. dtype: The dense feature's dtype. Returns: A Tensor. rrpadding_z[^A-Za-z0-9_.\-/]_)rnamekey_)r^getndimsdimsvaluerconvert_to_tensorrr-resubrreshaperconstantr'rTensor)rcrrMrrNkey_names rryz"_ParseOpParams._make_dense_defaults8''++C0M EKK!O 1 #  --6==(Bau> & ';S# FF-- X7 !))-<    #,,Ru=   -7BFF#7cBB-- X7 !))-? rct|tr|j||yt|tr|j ||yt|t r|j ||yt|tr|j||yt|tr|j||ytd|d|d)z1Adds the specified feature to this ParseOpParams.zInvalid feature :r&N) r'r_add_varlen_featurerB_add_sparse_featurerJ_add_fixed_len_featurerO_add_fixed_len_sequence_featurer_add_ragged_featurer)rcrrps rrlz_ParseOpParams._add_features'=) sG, G] + sG, G_ - !!#w/ G4 5 **38 G] + sG, )#ay: ;;rcv|jstd|d||j||jy)zAdds a VarLenFeature.Missing type for feature . Received feature=N)rr)_add_sparse_keyrs rrz"_ParseOpParams._add_varlen_feature s= ==  %cU*=gY G IIgmm,rc ||jvrC|j|jj|}||k7rtd|d|d|dy|jj ||jj |y)z3Adds a sparse key & dtype, checking for duplicates.Conflicting type  vs for feature r&N)rXrYindexr)append)rcrroriginal_dtypes rrz_ParseOpParams._add_sparse_keys d(()9)9)?)?)DEn 5 /tE7-uA NP P ! c" u%rc|jstd|d|jstd|d|jstd|d|d|j}t |t r|g}n#t |dkDrtjdt|D]"}|j|tj$|j|j|jy) zAdds a SparseFeature.z$Missing index_key for SparseFeature r&z$Missing value_key for SparseFeature rrzsSparseFeature is a complicated feature config and should only be used after careful consideration of VarLenFeature.N) rFr)r8rr'r(rWrwarningrjrrr+)rcrrp index_keysrFs rrz"_ParseOpParams._add_sparse_features    =gYaH II    =gYaH II == 23%7J!!% &&""J*c"seD"")!- ..  ! 1 1 3 =cUC--4]],=Q@ AAOO3\227==ABGMM*(!(!6!6d#)rc|jstd|d|d|jtd|d|d|jj ||j j t j|j|jj |j|jrd|j|<|j|j|j|<yy)zAdds a FixedLenSequenceFeature.rrr&Nr) rr)rMrZrr]rr\r[rRr^rNrs rrz._ParseOpParams._add_fixed_len_sequence_featureLs == 23%7J!!% &&}} 3C58K!!% &&OO3\227==ABGMM*!%d#(!(!6!6d#)rc ||jvr|j|jj|}|j|jj|}||k7rt d|d|d|d||k7rt d|d|d|dy|jj ||jj ||jj |y)z3Adds a ragged key & dtype, checking for duplicates.rrrr&zConflicting partition type N)r_r`rrar)r)rcr value_type split_typeoriginal_value_typeoriginal_split_types r_add_ragged_keyz_ParseOpParams._add_ragged_key\s d 33D4D4D4J4J34OP 33D4D4D4J4J34OP  *,-@,A&<}SE<= =  *67J6K4&<}SE<= = + c" $$Z0 $$Z0rcH|j|n |j}|j||j|j|jD]R}t |t jr|j|jtj|jTy)zAdds a RaggedFeature.N) r8rrr:r9r'rr#rrr+)rcrrpr8r<s rrz"_ParseOpParams._add_ragged_featurels~((0g6G6GIGMM73K3KL''7  =#A#A B Y]]FLL$55 77rc t|jt|jk7r8tdt|jdt|jdt|jt|jk7r8tdt|jdt|jdt|j t|j k7r8tdt|j dt|j dt|jt|jk7r8tdt|jdt|jdt|jt|jk7r8tdt|jdt|jdt|j}t|j }t|j}|j|s7td|jd |j d |j||j|s7td |jd |jd |j||j|s7td |jd |j d |j|y)z-Validates the features in this ParseOpParams.z0len(self.dense_shapes) != len(self.dense_keys): rr&z/len(self.dense_types) != len(self.dense_keys): z1len(self.sparse_types) != len(self.sparse_keys): z7len(self.ragged_value_types) != len(self.ragged_keys): z7len(self.ragged_split_types) != len(self.ragged_keys): z6Dense and sparse keys must not intersect; dense_keys: z, sparse_keys: z, intersection: z6Dense and ragged keys must not intersect; dense_keys: z, ragged_keys: z8Ragged and sparse keys must not intersect; ragged_keys: N) rWr]rZr)r[rYrXr`r_raset isdisjoint intersection)rc dense_key_setsparse_key_setragged_key_sets rrbz_ParseOpParams._validateus 4  T__!55 Id//01c$//6J5K1N OO 4  DOO 44 Hd../0S5I4J!M NN 4  T%5%5!66 Jd//01c$:J:J6K5LAO PP 4 " "#s4+;+;'<<  C (( ) *$s43C3C/D.EQ H II 4 " "#s4+;+;'<<  C (( ) *$s43C3C/D.EQ H II(M))*N))*N  # #N 3  B __ _T-=-=,>>N  ' ' 7 8 : ;;  # #N 3  B __ _T-=-=,>>N  ' ' 7 8 : ;;  $ $^ 4  D    od.>.>-??O  ( ( 8 9 ; << 5r) NNNNNNNNN)rrrrrf classmethodrqpropertyrtrvr{ryrlrrrrrrrrbrrrrTrTas#L  " "&"&"H: = = P P   $L <- &;*707 1 7%>A ,yy",!'"4"45 ;I,RK-0'2B2B-9;" ;  #))99,)9)9:;""'"4"45 QI$RK%,%=%=w?O?OQ" QgclS)\W H -cC [Ms8 Hc Ht|tjrt|tjrCt j |j|}tjj|||Stj|tjd|jgtj|ddgdStj||j|}t|tj r"tjj#|||St|tj$r"tjj'|||St|tj(r"tjj+|||St|tj,r"tjj/|||St|tj0r"tjj3|||St5d|) aCreates a RaggedTensor from a values tensor and a partition tensor. Args: values: The values tensor for the new RaggedTensor. partition: The partition configuration object. Specifies the key that should be used to look up the partition tensor (unless partition is a RaggedFeature.UniformRowLength, in which case there is no partition tensor). tensor_dict: The dictionary mapping keys to tensors. row_splits_dtype: The dtype for the partition tensor. validate: Whether to validate that the values form a valid RaggedTensor. Returns: A new RaggedTensor formed from the values and partition tensors. r~rrNraxisUnhandled partition type )r'rr#r rrrr$from_uniform_row_lengthrrconcatrMr castrrrrfrom_row_lengthsr from_row_startsr!from_row_limitsr"from_value_rowidsr))rr<rr:r;r$ partition_ts rrrs" =99:&-445$$Y%5%5=MNf  ' ' ? ? &8@--  vy'7'7    !9??6#:12#> ?a(IJJ-- IMM : ??rc  t|tjr8|jdkDrt j |j |jj}tjjtjj|j|||j|z|Stj|jtj d|j gtj"|jddgd}tjj||j|j z|S||j$}|jj|jjk7r*t'j(||jj}g} |B|r4| j+t-j.||jd|z|j}t j0| 5t|tj2tj4frt|tj2r |ddddf}|jtj6|j9|j;z} |j=tjj?|j| |cdddSt|tj@r|jtj6|j9|j;z} |j=tjjC|j| |cdddSt|tjDrN|j=tjjG|j|j|cdddSt|tjHrt'jJtMjN|dzdd} |jtj6t'jP| d |j;z} tjjGtjjS|j| || |cdddStUd |#1swYyxYw) aAdds a batched ragged partition tensor to a batched ragged tensor. Args: rt: A RaggedTensor with shape [batch_size, ...]. partition: The partition configuration object. Specifies the key that should be used to look up the partition tensor (unless partition is a RaggedFeature.UniformRowLength, in which case there is no partition tensor). The specified tensor must have shape [batch_size, ...]. tensor_dict: The dictionary mapping keys to tensors. feature_key: The name of the feature being parsed (for error messages). validate: Whether to validate that the values form a valid RaggedTensor. outer_splits: If not None, then we have two batch dimensions, and this is the row-splits for the collapsed batch dimension. Every partition tensor must have an outer row_splits that matches this value. Returns: A new RaggedTensor where each batch item `rt[i]` has been partitioned using the `partition_t[i]`. rrrNrrz1Feature %s: values and partitions are not aligned)messageT) exclusiver)+r'rr#rrrr$rrr rrrrrrrrMrr rrr assert_equalcontrol_dependenciesrr!repeat row_starts row_lengths with_valuesrr rrrr"maximumr reduce_maxcumsumrr))rr<r feature_keyr;rr$ reshaped_valsrchecksadjusted_limitsadjusted_startsnrowsadjusted_rowidss rrr%s)* =99: ~~$$Y%5%5r}}7J7JKf  ' ' 7 7  $ $ < <ii( = 4 --6 ! 8  '' 93C3C    !9??299#=ab#A B4LMm  ' ' 7 7 )*:*::X8OOIMM*+!4!44-- R]]-@-@AK & mmI**  ..E $$K '@)m55+5578 I}66 7!!QR%( #**Y-=-= --/;224.66o  $ $  $ $ 4 4ii8 5 =>@@ I}66 7#**Y-=-= --/;224.66o  $ $  $ $ 4 4ii8 5 =>@@ I}77 8  $ $  $ $ 5 5ii++h 6 @A#@@( I}88 9  $ $[1_1 =qBe#**Y-=-= //%4 0+2I2I2K.MMo  ' ' 8 8  $ $ 6 6ii8 7 =  93@@> 0 > ???@@s(C S(BSAS-CSSS'c :|>t||Dcgc]'\}}tjj||d)}}}|jdk(r|St||Dcgc]'\}}tjj||d)c}}Scc}}wcc}}w)z4Builds RaggedTensors from the outputs of a parse op.Frr)rxr rrr)serialized_shape ragged_valuesragged_row_splitsragged_inner_splitsvalsplits r_build_ragged_tensorsrws $ /BC S% ""2232NMq  /@A  S% ""2232N  s ,B!,BrE) rr>rtensorflow.python.frameworkrrrrrtensorflow.python.opsrr r r tensorflow.python.ops.raggedr r tensorflow.python.platformr tensorflow.python.util.tf_exportrr?rrrBrJrOrTrrrrrrrrs5 3.+.4++*,8616 ?4F"GH*K**?WIFI eIKLNeIeIP #5"GHG@KEGG@IG@T %9;L$MN*,k,,:<*O*& '+-FGI94k448:9I9By<yO@j/3r