AVhWP dZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd l m Z dd l mZdd l mZdd l mZdd lmZddlmZddlmZdZdZdZej4eedej6de d#dZej4eedej6dee j:fdZej4eedej6deddde j:fdZej4eedej6de d$dZ ej4eedej6dedde jBdfdZ"d#dZ#ejHGd d!ejJejLd!d"Z'y)%zThis API defines FeatureColumn for sequential input. NOTE: This API is a work in progress and will likely be changing frequently. N)feature_column_v2) serialization)utils)dtypes)ops) tensor_shape) array_ops) check_ops) parsing_ops) sparse_ops) deprecation) tf_export) doc_controlsa Warning: tf.feature_column is not recommended for new code. Instead, feature preprocessing can be done directly using either [Keras preprocessing layers](https://www.tensorflow.org/guide/migrate/migrating_feature_columns) or through the one-stop utility [`tf.keras.utils.FeatureSpace`](https://www.tensorflow.org/api_docs/python/tf/keras/utils/FeatureSpace) built on top of them. See the [migration guide](https://tensorflow.org/guide/migrate) for details. zUse Keras preprocessing layers instead, either directly or via the `tf.keras.utils.FeatureSpace` utility. Each of `tf.feature_column.*` has a functional equivalent in `tf.keras.layers` for feature preprocessing when training a Keras model.c tj|ddtj|g}tj|t j dj|j}tj|ddtj|g}tj|t j dj|j}tj||||g5tj|d }tjtj|d tjd g|gd ggd }d d d tj|gdS#1swY!xYw) aReplicates `context_input` across all timesteps of `sequence_input`. Expands dimension 1 of `context_input` then tiles it `sequence_length` times. This value is appended to `sequence_input` on dimension 2 and the result is returned. Args: context_input: A `Tensor` of dtype `float32` and shape `[batch_size, d1]`. sequence_input: A `Tensor` of dtype `float32` and shape `[batch_size, padded_length, d0]`. Returns: A `Tensor` of dtype `float32` and shape `[batch_size, padded_length, d0 + d1]`. Raises: ValueError: If `sequence_input` does not have rank 3 or `context_input` does not have rank 2. zsequence_input must have rank 3)messagedataz/sequence_input must have dtype float32; got {}.)rzcontext_input must have rank 2z.context_input must have dtype float32; got {}.rN)r assert_rankr shape assert_typerfloat32formatdtypercontrol_dependenciestile expand_dimsconcat) context_inputsequence_inputseq_rank_checkseq_type_checkctx_rank_checkctx_type_check padded_lengthtiled_context_inputs h/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/feature_column/sequence_feature_column.pyconcatenate_context_inputr)5sX(((/ OON + , .. (( nn?FF    !. ((. OOM * + -. (( nn>EE    .  ~~~FH:OON3A6M#..mQ/1# 4a8::   >+>? CC ::s 2AE//E8z8feature_column.sequence_categorical_column_with_identitycXtjtj|||S)aReturns a feature column that represents sequences of integers. Pass this to `embedding_column` or `indicator_column` to convert sequence categorical data into dense representation for input to sequence NN, such as RNN. Example: ```python watches = sequence_categorical_column_with_identity( 'watches', num_buckets=1000) watches_embedding = embedding_column(watches, dimension=10) columns = [watches_embedding] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) sequence_feature_layer = SequenceFeatures(columns) sequence_input, sequence_length = sequence_feature_layer(features) sequence_length_mask = tf.sequence_mask(sequence_length) rnn_cell = tf.keras.layers.SimpleRNNCell(hidden_size) rnn_layer = tf.keras.layers.RNN(rnn_cell) outputs, state = rnn_layer(sequence_input, mask=sequence_length_mask) ``` Args: key: A unique string identifying the input feature. num_buckets: Range of inputs. Namely, inputs are expected to be in the range `[0, num_buckets)`. default_value: If `None`, this column's graph operations will fail for out-of-range inputs. Otherwise, this value must be in the range `[0, num_buckets)`, and will replace out-of-range inputs. Returns: A `SequenceCategoricalColumn`. Raises: ValueError: if `num_buckets` is less than one. ValueError: if `default_value` is not in range `[0, num_buckets)`. key num_buckets default_value)fcSequenceCategoricalColumn categorical_column_with_identityr+s r()sequence_categorical_column_with_identityr2fs0Z % %)){-I JJz;feature_column.sequence_categorical_column_with_hash_bucketcXtjtj|||S)aA sequence of categorical terms where ids are set by hashing. Pass this to `embedding_column` or `indicator_column` to convert sequence categorical data into dense representation for input to sequence NN, such as RNN. Example: ```python tokens = sequence_categorical_column_with_hash_bucket( 'tokens', hash_bucket_size=1000) tokens_embedding = embedding_column(tokens, dimension=10) columns = [tokens_embedding] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) sequence_feature_layer = SequenceFeatures(columns) sequence_input, sequence_length = sequence_feature_layer(features) sequence_length_mask = tf.sequence_mask(sequence_length) rnn_cell = tf.keras.layers.SimpleRNNCell(hidden_size) rnn_layer = tf.keras.layers.RNN(rnn_cell) outputs, state = rnn_layer(sequence_input, mask=sequence_length_mask) ``` Args: key: A unique string identifying the input feature. hash_bucket_size: An int > 1. The number of buckets. dtype: The type of features. Only string and integer types are supported. Returns: A `SequenceCategoricalColumn`. Raises: ValueError: `hash_bucket_size` is not greater than 1. ValueError: `dtype` is neither string nor integer. r,hash_bucket_sizer)r/r0#categorical_column_with_hash_bucketr5s r(,sequence_categorical_column_with_hash_bucketr8s1T % %,,$4EC DDr3z?feature_column.sequence_categorical_column_with_vocabulary_filec ^tjtj||||||S)aA sequence of categorical terms where ids use a vocabulary file. Pass this to `embedding_column` or `indicator_column` to convert sequence categorical data into dense representation for input to sequence NN, such as RNN. Example: ```python states = sequence_categorical_column_with_vocabulary_file( key='states', vocabulary_file='/us/states.txt', vocabulary_size=50, num_oov_buckets=5) states_embedding = embedding_column(states, dimension=10) columns = [states_embedding] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) sequence_feature_layer = SequenceFeatures(columns) sequence_input, sequence_length = sequence_feature_layer(features) sequence_length_mask = tf.sequence_mask(sequence_length) rnn_cell = tf.keras.layers.SimpleRNNCell(hidden_size) rnn_layer = tf.keras.layers.RNN(rnn_cell) outputs, state = rnn_layer(sequence_input, mask=sequence_length_mask) ``` Args: key: A unique string identifying the input feature. vocabulary_file: The vocabulary file name. vocabulary_size: Number of the elements in the vocabulary. This must be no greater than length of `vocabulary_file`, if less than length, later values are ignored. If None, it is set to the length of `vocabulary_file`. num_oov_buckets: Non-negative integer, the number of out-of-vocabulary buckets. All out-of-vocabulary inputs will be assigned IDs in the range `[vocabulary_size, vocabulary_size+num_oov_buckets)` based on a hash of the input value. A positive `num_oov_buckets` can not be specified with `default_value`. default_value: The integer ID value to return for out-of-vocabulary feature values, defaults to `-1`. This can not be specified with a positive `num_oov_buckets`. dtype: The type of features. Only string and integer types are supported. Returns: A `SequenceCategoricalColumn`. Raises: ValueError: `vocabulary_file` is missing or cannot be opened. ValueError: `vocabulary_size` is missing or < 1. ValueError: `num_oov_buckets` is a negative integer. ValueError: `num_oov_buckets` and `default_value` are both specified. ValueError: `dtype` is neither string nor integer. r,vocabulary_filevocabulary_sizenum_oov_bucketsr.r)r/r0'categorical_column_with_vocabulary_filer:s r(0sequence_categorical_column_with_vocabulary_filer?s8x % %00)))%  r3z?feature_column.sequence_categorical_column_with_vocabulary_listc \tjtj|||||S)atA sequence of categorical terms where ids use an in-memory list. Pass this to `embedding_column` or `indicator_column` to convert sequence categorical data into dense representation for input to sequence NN, such as RNN. Example: ```python colors = sequence_categorical_column_with_vocabulary_list( key='colors', vocabulary_list=('R', 'G', 'B', 'Y'), num_oov_buckets=2) colors_embedding = embedding_column(colors, dimension=3) columns = [colors_embedding] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) sequence_feature_layer = SequenceFeatures(columns) sequence_input, sequence_length = sequence_feature_layer(features) sequence_length_mask = tf.sequence_mask(sequence_length) rnn_cell = tf.keras.layers.SimpleRNNCell(hidden_size) rnn_layer = tf.keras.layers.RNN(rnn_cell) outputs, state = rnn_layer(sequence_input, mask=sequence_length_mask) ``` Args: key: A unique string identifying the input feature. vocabulary_list: An ordered iterable defining the vocabulary. Each feature is mapped to the index of its value (if present) in `vocabulary_list`. Must be castable to `dtype`. dtype: The type of features. Only string and integer types are supported. If `None`, it will be inferred from `vocabulary_list`. default_value: The integer ID value to return for out-of-vocabulary feature values, defaults to `-1`. This can not be specified with a positive `num_oov_buckets`. num_oov_buckets: Non-negative integer, the number of out-of-vocabulary buckets. All out-of-vocabulary inputs will be assigned IDs in the range `[len(vocabulary_list), len(vocabulary_list)+num_oov_buckets)` based on a hash of the input value. A positive `num_oov_buckets` can not be specified with `default_value`. Returns: A `SequenceCategoricalColumn`. Raises: ValueError: if `vocabulary_list` is empty, or contains duplicate keys. ValueError: `num_oov_buckets` is a negative integer. ValueError: `num_oov_buckets` and `default_value` are both specified. ValueError: if `dtype` is not integer or string. r,vocabulary_listrr.r=)r/r0'categorical_column_with_vocabulary_listrAs r(0sequence_categorical_column_with_vocabulary_listrD s5t % %00)%) + ,,r3z&feature_column.sequence_numeric_column)rgctj||}|js'|jst dj |||%t |stdj |t|||||S)aReturns a feature column that represents sequences of numeric data. Example: ```python temperature = sequence_numeric_column('temperature') columns = [temperature] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) sequence_feature_layer = SequenceFeatures(columns) sequence_input, sequence_length = sequence_feature_layer(features) sequence_length_mask = tf.sequence_mask(sequence_length) rnn_cell = tf.keras.layers.SimpleRNNCell(hidden_size) rnn_layer = tf.keras.layers.RNN(rnn_cell) outputs, state = rnn_layer(sequence_input, mask=sequence_length_mask) ``` Args: key: A unique string identifying the input features. shape: The shape of the input data per sequence id. E.g. if `shape=(2,)`, each example must contain `2 * sequence_length` values. default_value: A single value compatible with `dtype` that is used for padding the sparse data into a dense `Tensor`. dtype: The type of values. normalizer_fn: If not `None`, a function that can be used to normalize the value of the tensor after `default_value` is applied for parsing. Normalizer function takes the input `Tensor` as its argument, and returns the output `Tensor`. (e.g. lambda x: (x - 3.0) / 4.2). Please note that even though the most common use case of this function is normalization, it can be used for any kind of Tensorflow transformations. Returns: A `SequenceNumericColumn`. Raises: TypeError: if any dimension in shape is not an int. ValueError: if any dimension in shape is not a positive integer. ValueError: if `dtype` is not convertible to `tf.float32`. )rr,z6dtype must be convertible to float. dtype: {}, key: {}z+normalizer_fn must be a callable. Given: {})rr.r normalizer_fn) r/ _check_shape is_integer is_floating ValueErrorrcallable TypeErrorSequenceNumericColumnr,rr.rrFs r(sequence_numeric_columnrOPs` //3 /%   e// **0&*< >>x '> 5<<]K MM  ! !  ##r3ctj|d|5t|dk(r|dcdddSg}|ddD]*}|jt j |d|,tj |5tj|dcdddcdddS#1swYnxYw dddy#1swYyxYw)z=Asserts that all tensors are equal and returns the first one.assert_all_equal)valuesrrN) r name_scopelenappendr assert_equalrr identity)tensorsnameassert_equal_opsts r(_assert_all_equal_and_returnr\s ~~d.w?, 7|q QZ,, QR[Ei44WQZCDE ! !"2 3,    +,, ,, ,,, ,,,s)CA C?B* C*B3 /CC ceZdZdZedZedZedZdZedZ dZ edZ d Z e d d Zy ) rMz%Represents sequences of numeric data.cy)NTselfs r( _is_v2_columnz#SequenceNumericColumn._is_v2_columns r3c|jSzSee `FeatureColumn` base class.r,r`s r(rYzSequenceNumericColumn.names  88Or3cX|jtj|jiSrd)r,r VarLenFeaturerr`s r(parse_example_specz(SequenceNumericColumn.parse_example_specs" HHk// ; <   r3rMrN)N)Nrsr)(r collections tensorflow.python.feature_columnrr/rrr{tensorflow.python.frameworkrrrtensorflow.python.opsr r r r tensorflow.python.utilr tensorflow.python.util.tf_exportrtensorflow.tools.docsr#_FEATURE_COLUMN_DEPRECATION_WARNING+_FEATURE_COLUMN_DEPRECATION_RUNTIME_WARNINGr)header deprecatedr2stringr8r?rDrrOr\register_feature_columnr} namedtuplerMr_r3r(rsQ D:>.+4++-,.6.'##,.Db89 EFIJ=A,JKG:,J^89 HIIJ8>}})DKJ:)DX89 LMIJFJEFCG;A== @KN:@F89 LMIJ<@CEEF =,KN:=,@89 34IJ"&*,"(..*. :#K5::#z ,&&]KCE]']r3