AVh dZddlZddlmZddlmZddlmZddlmZddlmZddl m Z dd l m Z dd l m Z dd l m Z dd l mZdd l mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZedej:d5dZedej: d6dZedej: d7dZ edej: d7dZ!edej: d6dZ"ed ej: d6d!Z#d"Z$ed#g$ej:d8d%Z%ed&g$ej:ejLdd'd( d9d)Z'ed#g$ej: d:d*Z(ejRejT d;d+ejVfd,Z,ed-ej: dd+ejbejdfd4Z7y)?z2Ragged operations for working with string Tensors.N) constant_op)dtypes)ops)tensor) tensor_util) array_ops)array_ops_stack)cond)gen_string_ops)map_fn) string_ops)ragged_array_ops)ragged_functional_ops)ragged_math_ops) ragged_tensor)compat) deprecation)dispatch) tf_exportzstrings.bytes_splitctj|d|g5tj|d}t |tj r-|j t|jcdddS|jj}| td|dk(r+ttj|gdcdddS|dk(rRtj|dd \}}}tj j!||dddf|dd cdddSttj j#|cdddS#1swYyxYw) aSplit string elements of `input` into bytes. Examples: >>> tf.strings.bytes_split('hello').numpy() array([b'h', b'e', b'l', b'l', b'o'], dtype=object) >>> tf.strings.bytes_split(['hello', '123']) Note that this op splits strings into bytes, not unicode characters. To split strings into unicode characters, use `tf.strings.unicode_split`. See also: `tf.io.decode_raw`, `tf.strings.split`, `tf.strings.unicode_split`. Args: input: A string `Tensor` or `RaggedTensor`: the strings to split. Must have a statically known rank (`N`). name: A name for the operation (optional). Returns: A `RaggedTensor` of rank `N+1`: the bytes that make up the source strings. StringsByteSplitinputnameNz(input must have a statically-known rank.rF) delimiter skip_emptyvalues value_rowidsnrowsvalidate)r name_scoper"convert_to_tensor_or_ragged_tensor isinstance RaggedTensorwith_flat_valuesstring_bytes_split flat_valuesshapendims ValueErrorr stackr string_splitfrom_value_rowids from_tensor)rrrankindicesr r+s ^/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/ragged/ragged_string_ops.pyr)r)(sH2 ~~d.8O  < ? BOO -:: 2% 1gvu  ' ' 9 9gadm58:OO& : : F Fu M N'OOOs AE8A E A E"'EEzstrings.unicode_encodec tj|d|g5tj|}|jj t dtj|r|jjj dkDr0|jt|j|||cdddS|jdkDr0|jt|j|||cdddStj|j|j|||cdddS|jj dk(r4ttj j#||||cdddS|jj dkDr{t%j&|t)j*dt%j|dg}t||||}t%j&||jddcdddS|jj dk(r t d tj j-|t)j*dt%j|t.j0 dgd }t||||} t%j&| gcdddS#1swYyxYw) aEncodes each sequence of Unicode code points in `input` into a string. `result[i1...iN]` is the string formed by concatenating the Unicode codepoints `input[1...iN, :]`, encoded using `output_encoding`. Args: input: An `N+1` dimensional potentially ragged integer tensor with shape `[D1...DN, num_chars]`. output_encoding: Unicode encoding that should be used to encode each codepoint sequence. Can be `"UTF-8"`, `"UTF-16-BE"`, or `"UTF-32-BE"`. errors: Specifies the response when an invalid codepoint is encountered (optional). One of: * `'replace'`: Replace invalid codepoint with the `replacement_char`. (default) * `'ignore'`: Skip invalid codepoints. * `'strict'`: Raise an exception for any invalid codepoint. replacement_char: The replacement character codepoint to be used in place of any invalid input when `errors='replace'`. Any valid unicode codepoint may be used. The default value is the default unicode replacement character which is 0xFFFD (U+65533). name: A name for the operation (optional). Returns: A `N` dimensional `string` tensor with shape `[D1...DN]`. #### Example: >>> input = tf.ragged.constant( ... [[71, 246, 246, 100, 110, 105, 103, 104, 116], [128522]]) >>> print(unicode_encode(input, 'UTF-8')) tf.Tensor([b'G\xc3\xb6\xc3\xb6dnight' b'\xf0\x9f\x98\x8a'], shape=(2,), dtype=string) UnicodeEncodeNz.Rank of input_tensor must be statically known.r) input_values input_splitsoutput_encodingerrorsreplacement_charrz'input_tensor's rank must be at least 1.out_typeFr#)rr$rr%r+r,r- is_raggedr*r(unicode_encode ragged_rank with_valuesr r row_splitsr'r1rreshaper r.from_row_splitsrint32) rr9r:r;r input_tensorflat_input_tensorflat_output_tensorragged_input_tensor output_tensors r4rBrBXsP ~~dOeW564 CCEJL' G HH|,  ! ! ' ' - - 1,, <33_f+ -.6464  # #a ''' <..+ -.6464(,,%,,%00+- /)64646    ! !Q &  & & 2 2< @ V%57;6464@    # #a '&--   ! !2y|'DR'H"I JL,,=,24DF  !3\5G5G5LMQ6464R    # #q (BCC ,88HH   ! !IOOL6<<HKL N I '':O'-/?A   3m646464s-BJ=85J=7-J=.AJ=;B J=B$J==Kzstrings.unicode_decodec tj|d|g5t|||||dcdddS#1swYyxYw)aDecodes each string in `input` into a sequence of Unicode code points. `result[i1...iN, j]` is the Unicode codepoint for the `j`th character in `input[i1...iN]`, when decoded using `input_encoding`. Args: input: An `N` dimensional potentially ragged `string` tensor with shape `[D1...DN]`. `N` must be statically known. input_encoding: String name for the unicode encoding that should be used to decode each string. errors: Specifies the response when an input string can't be converted using the indicated encoding. One of: * `'strict'`: Raise an exception for any illegal substrings. * `'replace'`: Replace illegal substrings with `replacement_char`. * `'ignore'`: Skip illegal substrings. replacement_char: The replacement codepoint to be used in place of invalid substrings in `input` when `errors='replace'`; and in place of C0 control characters in `input` when `replace_control_characters=True`. replace_control_characters: Whether to replace the C0 control characters `(U+0000 - U+001F)` with the `replacement_char`. name: A name for the operation (optional). Returns: A `N+1` dimensional `int32` tensor with shape `[D1...DN, (num_chars)]`. The returned tensor is a `tf.Tensor` if `input` is a scalar, or a `tf.RaggedTensor` otherwise. #### Example: >>> input = [s.encode('utf8') for s in (u'G\xf6\xf6dnight', u'\U0001f60a')] >>> tf.strings.unicode_decode(input, 'UTF-8').to_list() [[71, 246, 246, 100, 110, 105, 103, 104, 116], [128522]] UnicodeDecodeF with_offsetsNrr$_unicode_decoderinput_encodingr:r;replace_control_charactersrs r4unicode_decoderWsGR ~~dOeW5K 5.&:J5E KKKK4=z#strings.unicode_decode_with_offsetsc tj|d|g5t|||||dcdddS#1swYyxYw)aDecodes each string into a sequence of code points with start offsets. This op is similar to `tf.strings.decode(...)`, but it also returns the start offset for each character in its respective string. This information can be used to align the characters with the original byte sequence. Returns a tuple `(codepoints, start_offsets)` where: * `codepoints[i1...iN, j]` is the Unicode codepoint for the `j`th character in `input[i1...iN]`, when decoded using `input_encoding`. * `start_offsets[i1...iN, j]` is the start byte offset for the `j`th character in `input[i1...iN]`, when decoded using `input_encoding`. Args: input: An `N` dimensional potentially ragged `string` tensor with shape `[D1...DN]`. `N` must be statically known. input_encoding: String name for the unicode encoding that should be used to decode each string. errors: Specifies the response when an input string can't be converted using the indicated encoding. One of: * `'strict'`: Raise an exception for any illegal substrings. * `'replace'`: Replace illegal substrings with `replacement_char`. * `'ignore'`: Skip illegal substrings. replacement_char: The replacement codepoint to be used in place of invalid substrings in `input` when `errors='replace'`; and in place of C0 control characters in `input` when `replace_control_characters=True`. replace_control_characters: Whether to replace the C0 control characters `(U+0000 - U+001F)` with the `replacement_char`. name: A name for the operation (optional). Returns: A tuple of `N+1` dimensional tensors `(codepoints, start_offsets)`. * `codepoints` is an `int32` tensor with shape `[D1...DN, (num_chars)]`. * `offsets` is an `int64` tensor with shape `[D1...DN, (num_chars)]`. The returned tensors are `tf.Tensor`s if `input` is a scalar, or `tf.RaggedTensor`s otherwise. #### Example: >>> input = [s.encode('utf8') for s in (u'G\xf6\xf6dnight', u'\U0001f60a')] >>> result = tf.strings.unicode_decode_with_offsets(input, 'UTF-8') >>> result[0].to_list() # codepoints [[71, 246, 246, 100, 110, 105, 103, 104, 116], [128522]] >>> result[1].to_list() # offsets [[0, 1, 3, 5, 6, 7, 8, 9, 10], [0]] UnicodeDecodeWithOffsetsTrPNrRrTs r4unicode_decode_with_offsetsr[sHr ~~d6@J 5.&:J5D JJJJrXzstrings.unicode_splitc tj|d|g5t||||dd}tt j |d|||cdddS#1swYyxYw)a]Splits each string in `input` into a sequence of Unicode code points. `result[i1...iN, j]` is the substring of `input[i1...iN]` that encodes its `j`th character, when decoded using `input_encoding`. Args: input: An `N` dimensional potentially ragged `string` tensor with shape `[D1...DN]`. `N` must be statically known. input_encoding: String name for the unicode encoding that should be used to decode each string. errors: Specifies the response when an input string can't be converted using the indicated encoding. One of: * `'strict'`: Raise an exception for any illegal substrings. * `'replace'`: Replace illegal substrings with `replacement_char`. * `'ignore'`: Skip illegal substrings. replacement_char: The replacement codepoint to be used in place of invalid substrings in `input` when `errors='replace'`. name: A name for the operation (optional). Returns: A `N+1` dimensional `int32` tensor with shape `[D1...DN, (num_chars)]`. The returned tensor is a `tf.Tensor` if `input` is a scalar, or a `tf.RaggedTensor` otherwise. #### Example: >>> input = [s.encode('utf8') for s in (u'G\xf6\xf6dnight', u'\U0001f60a')] >>> tf.strings.unicode_split(input, 'UTF-8').to_list() [[b'G', b'\xc3\xb6', b'\xc3\xb6', b'd', b'n', b'i', b'g', b'h', b't'], [b'\xf0\x9f\x98\x8a']] UnicodeSplitFrPr=r9r:r;Nrr$rSrBr expand_dims)rrUr:r;r codepointss r4 unicode_splitrb&seL ~~dNUG4+ !15uNJ $$Z4&)  ++++s 4AA z"strings.unicode_split_with_offsetsc tj|d|g5t||||dd\}}tt j |d|||}||fcdddS#1swYyxYw)a!Splits each string into a sequence of code points with start offsets. This op is similar to `tf.strings.decode(...)`, but it also returns the start offset for each character in its respective string. This information can be used to align the characters with the original byte sequence. Returns a tuple `(chars, start_offsets)` where: * `chars[i1...iN, j]` is the substring of `input[i1...iN]` that encodes its `j`th character, when decoded using `input_encoding`. * `start_offsets[i1...iN, j]` is the start byte offset for the `j`th character in `input[i1...iN]`, when decoded using `input_encoding`. Args: input: An `N` dimensional potentially ragged `string` tensor with shape `[D1...DN]`. `N` must be statically known. input_encoding: String name for the unicode encoding that should be used to decode each string. errors: Specifies the response when an input string can't be converted using the indicated encoding. One of: * `'strict'`: Raise an exception for any illegal substrings. * `'replace'`: Replace illegal substrings with `replacement_char`. * `'ignore'`: Skip illegal substrings. replacement_char: The replacement codepoint to be used in place of invalid substrings in `input` when `errors='replace'`. name: A name for the operation (optional). Returns: A tuple of `N+1` dimensional tensors `(codepoints, start_offsets)`. * `codepoints` is an `int32` tensor with shape `[D1...DN, (num_chars)]`. * `offsets` is an `int64` tensor with shape `[D1...DN, (num_chars)]`. The returned tensors are `tf.Tensor`s if `input` is a scalar, or `tf.RaggedTensor`s otherwise. #### Example: >>> input = [s.encode('utf8') for s in (u'G\xf6\xf6dnight', u'\U0001f60a')] >>> result = tf.strings.unicode_split_with_offsets(input, 'UTF-8') >>> result[0].to_list() # character substrings [[b'G', b'\xc3\xb6', b'\xc3\xb6', b'd', b'n', b'i', b'g', b'h', b't'], [b'\xf0\x9f\x98\x8a']] >>> result[1].to_list() # offsets [[0, 1, 3, 5, 6, 7, 8, 9, 10], [0]] UnicodeSplitWithOffsetsFTrPr=r^Nr_)rrUr:r;rraoffsetscharss r4unicode_split_with_offsetsrgVsxl ~~d5w? )%*:E7;=J $$Z4&)  +E '>   s ;AA'c,tj|d}|jj}| t d|dkDrtj |s%tj j||dz }n\|j|dz krJ|jtj j|j||jz dz }tj |r"tj|jdg}ntj|dg}|rtj}ntj}||||||} |dk(r| j } |r| j"} ntj j%| j | j&d } |dkDr|j| } |rLtj j%| j"| j&d } |dkDr|j| } |r|  fS| S) z2Decodes each string into a sequence of codepoints.rrz)Rank of `input` must be statically known.rrCr=)rrUr:r;rVrFr@)rr%r+r,r-rAr'r1rCr(r*rrFr r[rW char_valueschar_to_byte_startsrGrE) rrUr:r;rVrQ input_ndims flat_input decode_op flat_resultrares r4rSrSs  : :5w O% !!+ @ AA1_  " "5 )((44 [1_5.e   [1_ ,$$  $ $ 0 0%(9(99A= 1 ?@e U#""5#4#4rd;J""52$/J::I--I # '!; =+A((J//g++;;!7!7%<IJQ))*5j**::  ) );+A+A;g q((1 w  z strings.split)v1ctj|d|g5tj|tj d}t |tjr/|jt|j||cdddS|jj}|dk(r-ttj|g||dcdddS|dk(s|ltj|||}tjj!|j"|j$dddf|j&dd cdddSttjj)|||cdddS#1swYyxYw) aSplit elements of `input` based on `sep` into a `RaggedTensor`. Let N be the size of `input` (typically N will be the batch size). Split each element of `input` based on `sep` and return a `RaggedTensor` containing the split tokens. Empty tokens are ignored. Example: >>> tf.strings.split('hello world').numpy() array([b'hello', b'world'], dtype=object) >>> tf.strings.split(['hello world', 'a b c']) If `sep` is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings. For example, `input` of `"1<>2<><>3"` and `sep` of `"<>"` returns `["1", "2", "", "3"]`. If `sep` is None or an empty string, consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Note that the above mentioned behavior matches python's str.split. Args: input: A string `Tensor` of rank `N`, the strings to split. If `rank(input)` is not known statically, then it is assumed to be `1`. sep: `0-D` string `Tensor`, the delimiter string. maxsplit: An `int`. If `maxsplit > 0`, limit of the split of the result. name: A name for the operation (optional). Raises: ValueError: If sep is not a string. Returns: A `RaggedTensor` of rank `N+1`, the strings split according to the delimiter. StringSplitrdtyperNrrsepmaxsplitFr)rr$rr%rstringr&r'r(string_split_v2r*r+r,r r.r r0r r3 dense_shaper1)rrwrxrr2 sparse_results r4rzrzsaN ~~dME73H  < < V]] 2E%334  # # %++S( ;= HH ;;  D qy _22E7;S( KA NHH dl 00 S8-m  ' ' 9 9%%$,,QT2))!, :HH&  $ $ 0 0 7hH'HHHsA&E7 >E7A)E7)E77Fr/z0delimiter is deprecated, please use sep instead.rcftj|d|g5tj||||}|dk(r |cdddS|dk(rTtj j |j|jdddf|jddcdddStd #1swYyxYw) a Split elements of `source` based on `delimiter`. Let N be the size of `source` (typically N will be the batch size). Split each element of `source` based on `delimiter` and return a `SparseTensor` or `RaggedTensor` containing the split tokens. Empty tokens are ignored. If `sep` is an empty string, each element of the `source` is split into individual strings, each containing one byte. (This includes splitting multibyte sequences of UTF-8.) If delimiter contains multiple bytes, it is treated as a set of delimiters with each considered a potential split point. Examples: >>> print(tf.compat.v1.string_split(['hello world', 'a b c'])) SparseTensor(indices=tf.Tensor( [[0 0] [0 1] [1 0] [1 1] [1 2]], ...), values=tf.Tensor([b'hello' b'world' b'a' b'b' b'c'], ...), dense_shape=tf.Tensor([2 3], shape=(2,), dtype=int64)) >>> print(tf.compat.v1.string_split(['hello world', 'a b c'], ... result_type="RaggedTensor")) Args: source: `1-D` string `Tensor`, the strings to split. sep: `0-D` string `Tensor`, the delimiter character, the string should be length 0 or 1. Default is ' '. skip_empty: A `bool`. If `True`, skip the empty strings from the result. delimiter: deprecated alias for `sep`. result_type: The tensor type for the result: one of `"RaggedTensor"` or `"SparseTensor"`. name: A name for the operation (optional). Raises: ValueError: If delimiter is not a string. Returns: A `SparseTensor` or `RaggedTensor` of rank `2`, the strings split according to the delimiter. The first column of the indices corresponds to the row in `source` and the second column corresponds to the index of the split component in this row. rs)rwrr SparseTensorNr'rFr5result_type must be 'RaggedTensor' or 'SparseTensor'.) rr$r r/rr'r0r r3r{r-)sourcerwrr result_typerr|s r4r/r/s` ~~dMF84 P++CJ)EMn$  P P  &  ' ' 9 9%%$,,QT2))!, : P P N OO P Ps B'AB' B''B0c<tjd|d|}tj|d|g5t j |t jd}|jjdk(rtj|d}|dk(r_|jjdk(r!tj|||cd d d St|||jcd d d S|d k(rt|||cd d d Std #1swYy xYw) aDSplit elements of `input` based on `sep`. Let N be the size of `input` (typically N will be the batch size). Split each element of `input` based on `sep` and return a `SparseTensor` or `RaggedTensor` containing the split tokens. Empty tokens are ignored. Examples: >>> print(tf.compat.v1.strings.split(['hello world', 'a b c'])) SparseTensor(indices=tf.Tensor( [[0 0] [0 1] [1 0] [1 1] [1 2]], ...), values=tf.Tensor([b'hello' b'world' b'a' b'b' b'c'], ...), dense_shape=tf.Tensor([2 3], shape=(2,), dtype=int64)) >>> print(tf.compat.v1.strings.split(['hello world', 'a b c'], ... result_type="RaggedTensor")) If `sep` is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings. For example, `input` of `"1<>2<><>3"` and `sep` of `"<>"` returns `["1", "2", "", "3"]`. If `sep` is None or an empty string, consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Note that the above mentioned behavior matches python's str.split. Args: input: A string `Tensor` of rank `N`, the strings to split. If `rank(input)` is not known statically, then it is assumed to be `1`. sep: `0-D` string `Tensor`, the delimiter character. maxsplit: An `int`. If `maxsplit > 0`, limit of the split of the result. result_type: The tensor type for the result: one of `"RaggedTensor"` or `"SparseTensor"`. source: alias for "input" argument. name: A name for the operation (optional). Raises: ValueError: If sep is not a string. Returns: A `SparseTensor` or `RaggedTensor` of rank `N+1`, the strings split according to the delimiter. rrrsrtrr~rrvNr'r)rdeprecated_argument_lookuprr$rr%rryr+r2rr`r rz to_sparser-)rrwrxrrrs r4strings_split_v1rQs^  0 0 uh (% ~~dME73P  < < V]] 2E {{1##E1-en$   Q ))%S8LPPu#AKKMPP  & Uh ?PP N OOPPsB DD+D DDinputsc xtjtjtj|||||xsdS)z(For docs, see: _RAGGED_REDUCE_DOCSTRING.RaggedSegmentJoin)rragged_reduce_aggregater reduce_joinunsorted_segment_join)raxiskeepdims separatorrs r4rrs9  0 0j>> 46#6 88rpzstrings.ngramsc tj|d|g5|d}d}nt|ttfrPt|dt j rt|dt j s td|d}|d}n)t|t j s td|}|}||dkr td| | tdtj|d tj }d } t|tjr2tj tj"|dd d ggd } d} t|tj$s|j"j& td|j"j&dk(r td|j"j&dk(r@tj$j)|dgd } t+| ||||||dcdddStj$j-||j"j&dz }|j.dkDrW|j1t+|j2||||||} | r tj4| j6 n| cdddS|d}||d }t|ttfs|g} n|} | D]}|dks td|zt9j:|j6|j<|| ||||\} }tj$j?| |d } | r tj4| j6 n| cdddS#1swYyxYw)a Create a tensor of n-grams based on `data`. Creates a tensor of n-grams based on `data`. The n-grams are created by joining windows of `width` adjacent strings from the inner axis of `data` using `separator`. The input data can be padded on both the start and end of the sequence, if desired, using the `pad_values` argument. If set, `pad_values` should contain either a tuple of strings or a single string; the 0th element of the tuple will be used to pad the left side of the sequence and the 1st element of the tuple will be used to pad the right side of the sequence. The `padding_width` arg controls how many padding values are added to each side; it defaults to `ngram_width-1`. If this op is configured to not have padding, or if it is configured to add padding with `padding_width` set to less than ngram_width-1, it is possible that a sequence, or a sequence plus padding, is smaller than the ngram width. In that case, no ngrams will be generated for that sequence. This can be prevented by setting `preserve_short_sequences`, which will cause the op to always generate at least one ngram per non-empty sequence. Examples: >>> tf.strings.ngrams(["A", "B", "C", "D"], 2).numpy() array([b'A B', b'B C', b'C D'], dtype=object) >>> tf.strings.ngrams(["TF", "and", "keras"], 1).numpy() array([b'TF', b'and', b'keras'], dtype=object) Args: data: A Tensor or RaggedTensor containing the source data for the ngrams. ngram_width: The width(s) of the ngrams to create. If this is a list or tuple, the op will return ngrams of all specified arities in list order. Values must be non-Tensor integers greater than 0. separator: The separator string used between ngram elements. Must be a string constant, not a Tensor. pad_values: A tuple of (left_pad_value, right_pad_value), a single string, or None. If None, no padding will be added; if a single string, then that string will be used for both left and right padding. Values must be Python strings. padding_width: If set, `padding_width` pad values will be added to both sides of each sequence. Defaults to `ngram_width`-1. Must be greater than 0. (Note that 1-grams are never padded, regardless of this value.) preserve_short_sequences: If true, then ensure that at least one ngram is generated for each input sequence. In particular, if an input sequence is shorter than `min(ngram_width) + 2*pad_width`, then generate a single ngram containing the entire sequence. If false, then no ngrams are generated for these short input sequences. name: The op name. Returns: A RaggedTensor of ngrams. If `data.shape=[D1...DN, S]`, then `output.shape=[D1...DN, NUM_NGRAMS]`, where `NUM_NGRAMS=S-ngram_width+1+2*padding_width`. Raises: TypeError: if `pad_values` is set to an invalid type. ValueError: if `pad_values`, `padding_width`, or `ngram_width` is set to an invalid value. StringNGramsNrrrz7pad_values must be a string, tuple of strings, or None.z%padding_width must be greater than 0.z4pad_values must be provided if padding_width is set.data)rruFr=rTzRank of data must be known.zData must have rank>0r@riz/All ngram_widths must be greater than 0. Got %s)r data_splitsr ngram_widthsleft_pad right_pad pad_widthpreserve_short_sequences)r rEr#) rr$r&listtuple util_compatbytes_or_text_types TypeErrorr-rr%rry tensor_libTensorrconcatr+r'r,from_row_startsngramsr1rCrDr rFr*r string_n_gramsrErG)r ngram_widthr pad_values padding_widthrrrr to_tensorr{rtoutputrwidth output_splitss r4rrsJ ~~dNTF3SChi Ju .A (G(GHA (G(GH EG GAhQ-i  K$C$C D EG Ghi ]Q%6 > ?? Z%7 M NN  ; ; 6 0DI$ ))*$$iood&;CR&@2$%GaPki dM66 7    !677 ::  q 011 ::  q  ' ' 7 7 1#8'b+y*m.6679SSCSCX))55 djj..264 ! k9j-)4 12f09  v11*,>DiSCSClm-"7m kD%= 1!]l l& J$%& && +99   OO!!9;FM ' ' 7 7-%8AF.7   V//( *'>v'FXF>>+..[C'!++ ""(&^)|(|dk7r#t|tr|dkDstd|ztjdd|g5t j |}|jj td|jtjk(r9tj|jdd}|jd |zd z}n.|jtj |j}t#||cdddS#1swYyxYw) aReturns a scalar string tensor with the contents of a RaggedTensor. Requires that `rt.shape.rank` is not `None`. Note: this converts the entire `RaggedTensor` into a single string scalar. If you want to convert individual elements, use `tf.strings.as_string(rt)`. >>> rt1 = tf.ragged.constant([[1, 2, 3], [4, 5]]) >>> ragged_tensor_to_string(rt1).numpy() b'[[1, 2, 3], [4, 5]]' >>> rt2 = tf.ragged.constant([[['a'], ['b', 'c']], [['d', 'e', 'f'], []]]) >>> ragged_tensor_to_string(rt2).numpy() b"[[['a'], ['b', 'c']], [['d', 'e', 'f'], []]]" >>> rt3 = tf.ragged.constant([[1], [2, 3, 4, 5, 6], [], [], [7], [8, 9]]) >>> ragged_tensor_to_string(rt3, summarize=2).numpy() b'[[1], [2, 3, ..., 5, 6], ..., [7], [8, 9]]' Args: rt: The RaggedTensor that should be converted to a string. summarize: If specified, then only the first and last `summarize` elements within each dimension are included in the string. If `-1` or `None`, then all elements are included. Nr=rz5Expected summarize to be -1 or a positive int, got %rAsStringz?RaggedTensor to_string requires that rt.shape.rank is not None.z(['\\])z\\\1')r&intr-rr$rr%r+r2rurryr regex_replacer*r( as_string_ragged_tensor_to_string)rrescapedstr_ts r4rr[s4 R i %)a- L   ~~dJ- 6  9 9" =B xx}} & '' xx6== ((WMg!!#-#"56e!!*"6"6r~~"FGe #E9 5 6 6 6s CDDcT|jjdk(r|n=tjfd|t j dt jdvr-tjt|dzkfdfdd tjd zd zS) aFReturns a scalar string tensor with the contents of `string_tensor`. Args: string_tensor: A potentially ragged tensor with dtype=string. summarize: Include only the first and last `summarize` elements of each dimension. If `-1` or `None`, then include all elements. Returns: A scalar string Tensor. rct|SN)r)srs r4z*_ragged_tensor_to_string..s*1i8rpN)fn_output_signature)r=Nr<cSr)piecessr4rz*_ragged_tensor_to_string..srpcHtjddg dgdS)Nz...rr)rr)rrsr4rz*_ragged_tensor_to_string..s1   JY %&)*= >rp[z, )r]) r+r2 map_fn_libr r TensorSpecrryr _nrowsr r) string_tensorrrs `@r4rrs" F   8&11$ FHFj YY}Y. F z%%f= = CCrpct|tjr|j|St j ||dS)Nr>r)r&rr'r"rr+)rr?s r4rrs9 223 <<< ** ??6H 5a 88rpct|dkr tdtj|d|5t j t j||cdddS#1swYyxYw)z0RaggedTensor implementation for tf.strings.join.rz-tf.strings.join: expected at least one input.RaggedStringJoinN)rr-rr$rmap_flat_valuesr string_join)rrrs r4rrs\  [1_ D EE ~~d.7< 0 01G1G1: <<<rs9 3.+<3+1&06,9>868.+6 ! *O"*O\ #$ $$) \4%\4@ #$ $$*.3 )K%)KX 01 (117;@%) 9J29Jx "# ##) ++$++\ /0 '006$( =1=@7t ?r" 9H#9Hx ~ TO(*?C267P* 7Px   46CG>P!>PB:445 8 ,,868  $) VCVCr:334  33 LL--]%@%@AB C353>*6ZD8#LL9:112< M$?$?@<3