AVho dZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl mZddl mZddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddl%m&Z&ddl%m'Z(ddl)m*Z*ddl+m,Z,ddl+m-Z-ddl.m/Z/dd l0m1Z1dd!l2m3Z3d"Z4d#Z5 d}d$Z6e3jne4e1d%g&e,jpde5 d~d'Z9Gd(d)e:Z;e3jne4e1d*g&e,jpde5 dd+ZZMdd?ZNd@ZOe jfdAZPddBZQGdCdDej|ZRejejGdEdFe:ZUGdGdHeUZV ddIZW ddJZXGdKdLeUZY ddMZZGdNdOeUZ[GdPdQe:Z\dRZ]ddSZ^dTZ_GdUdVeVejdVgdWZaGdXdYeVeYejdYdZd[gZbGd\d]eVe[ejd]d^Zcd_ZdGd`daeVe[ejdadbZedcZfGdddeeYejdegdfZgGdgdheYejdhdiZhGdjdkeYejdkdlZiGdmdneYejdndoZjGdpdqeYejdqdrZkGdsdteYejdtgduZldvZmGdwdxeVe[ejdxdygZndzZoGd{d|eYejd|dygZpy)aThis API defines FeatureColumn abstraction. FeatureColumns can also be transformed into a generic input layer for custom models using `input_layer`. NOTE: Functions prefixed with "_" indicate experimental or private parts of the API subject to change, and should not be relied upon! NOTE: The new feature columns are being developed in feature_column_v2.py and are a somewhat duplicate of the code here. Please make sure to update logic in both places. N)context)utils)dtypes)ops) sparse_tensor) tensor_shape)base) array_ops)array_ops_stack) check_ops)cond) embedding_ops)init_ops) lookup_ops)math_ops)nn_ops) parsing_ops)resource_variable_ops) sparse_ops) string_ops)template)variable_scope) variables)gfile) tf_logging)checkpoint_utils) deprecation)nest)collections_abc) 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.cdtD],}t|trtdj |t xsgt jjvr)jt jjt jjvr)jt jjfd} |r| Stj|dj5| cdddS#1swYyxYw)zz<_internal_input_layer.._get_logits..n key default_nameweight_collections trainablershapescope) _LazyBuildersortedappendr_var_scope_name_get_dense_tensor_variable_shape num_elementsr r6reshaperget_collection GraphKeysGLOBAL_VARIABLESget_variable_scoper'"_verify_static_batch_size_equalityconcat)builderoutput_tensorsordered_columnscolumntensorr@ batch_size output_tensorcols_to_output_tensors cols_to_varsfeature_columnsfeaturesr4r3s r* _get_logitsz*_internal_input_layer.._get_logitsjsL8$GNO.>?9V$  ( ( V33 59)) 1*!--::< __V,Q/ !)) :|46 m,  #"%!3!3mm,,"557<<">,v  " -+8  (%999*'~G   NA ..)99s CE  E input_layerr1valuesN) _normalize_feature_columns isinstance _DenseColumn ValueErrorformatlistrrCrDr<MODEL_VARIABLESrrV) rRrQr3r4rPr8rO from_templaterKrSs ````` ` r*_internal_input_layerr_Ss/?/Lf fl +  < =  & & M(//2C E ]s D&&D/zfeature_column.input_layer)v1c$t||||||S)a Returns a dense `Tensor` as input layer based on given `feature_columns`. Generally a single example in training data is described with FeatureColumns. At the first layer of the model, this column oriented data should be converted to a single `Tensor`. Example: ```python price = numeric_column('price') keywords_embedded = embedding_column( categorical_column_with_hash_bucket("keywords", 10K), dimensions=16) columns = [price, keywords_embedded, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) dense_tensor = input_layer(features, columns) for units in [128, 64, 32]: dense_tensor = tf.compat.v1.layers.dense(dense_tensor, units, tf.nn.relu) prediction = tf.compat.v1.layers.dense(dense_tensor, 1) ``` Args: features: A mapping from key to tensors. `_FeatureColumn`s look up via these keys. For example `numeric_column('price')` will look at 'price' key in this dict. Values can be a `SparseTensor` or a `Tensor` depends on corresponding `_FeatureColumn`. feature_columns: An iterable containing the FeatureColumns to use as inputs to your model. All items should be instances of classes derived from `_DenseColumn` such as `numeric_column`, `embedding_column`, `bucketized_column`, `indicator_column`. If you have categorical features, you can wrap them with an `embedding_column` or `indicator_column`. weight_collections: A list of collection names to which the Variable will be added. Note that variables will also be added to collections `tf.GraphKeys.GLOBAL_VARIABLES` and `ops.GraphKeys.MODEL_VARIABLES`. trainable: If `True` also add the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). cols_to_vars: If not `None`, must be a dictionary that will be filled with a mapping from `_FeatureColumn` to list of `Variable`s. For example, after the call, we might have cols_to_vars = {_EmbeddingColumn( categorical_column=_HashedCategoricalColumn( key='sparse_feature', hash_bucket_size=5, dtype=tf.string), dimension=10): [ > < < : : 8 8 0 0 . .r-rczfeature_column.linear_modelctjdd5}t|j}dddt|||||} | |} ||j | j | S#1swYExYw)aReturns a linear prediction `Tensor` based on given `feature_columns`. This function generates a weighted sum based on output dimension `units`. Weighted sum refers to logits in classification problems. It refers to the prediction itself for linear regression problems. Note on supported columns: `linear_model` treats categorical columns as `indicator_column`s. To be specific, assume the input as `SparseTensor` looks like: ```python shape = [2, 2] { [0, 0]: "a" [1, 0]: "b" [1, 1]: "c" } ``` `linear_model` assigns weights for the presence of "a", "b", "c' implicitly, just like `indicator_column`, while `input_layer` explicitly requires wrapping each of categorical columns with an `embedding_column` or an `indicator_column`. Example of usage: ```python price = numeric_column('price') price_buckets = bucketized_column(price, boundaries=[0., 10., 100., 1000.]) keywords = categorical_column_with_hash_bucket("keywords", 10K) keywords_price = crossed_column('keywords', price_buckets, ...) columns = [price_buckets, keywords, keywords_price ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) prediction = linear_model(features, columns) ``` The `sparse_combiner` argument works as follows For example, for two features represented as the categorical columns: ```python # Feature 1 shape = [2, 2] { [0, 0]: "a" [0, 1]: "b" [1, 0]: "c" } # Feature 2 shape = [2, 3] { [0, 0]: "d" [1, 0]: "e" [1, 1]: "f" [1, 2]: "f" } ``` with `sparse_combiner` as "mean", the linear model outputs consequently are: ``` y_0 = 1.0 / 2.0 * ( w_a + w_b ) + w_d + b y_1 = w_c + 1.0 / 3.0 * ( w_e + 2.0 * w_f ) + b ``` where `y_i` is the output, `b` is the bias, and `w_x` is the weight assigned to the presence of `x` in the input features. Args: features: A mapping from key to tensors. `_FeatureColumn`s look up via these keys. For example `numeric_column('price')` will look at 'price' key in this dict. Values are `Tensor` or `SparseTensor` depending on corresponding `_FeatureColumn`. feature_columns: An iterable containing the FeatureColumns to use as inputs to your model. All items should be instances of classes derived from `_FeatureColumn`s. units: An integer, dimensionality of the output space. Default value is 1. sparse_combiner: A string specifying how to reduce if a categorical column is multivalent. Except `numeric_column`, almost all columns passed to `linear_model` are considered as categorical columns. It combines each categorical column independently. Currently "mean", "sqrtn" and "sum" are supported, with "sum" the default for linear model. "sqrtn" often achieves good accuracy, in particular with bag-of-words columns. * "sum": do not normalize features in the column * "mean": do l1 normalization on features in the column * "sqrtn": do l2 normalization on features in the column weight_collections: A list of collection names to which the Variable will be added. Note that, variables will also be added to collections `tf.GraphKeys.GLOBAL_VARIABLES` and `ops.GraphKeys.MODEL_VARIABLES`. trainable: If `True` also add the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). cols_to_vars: If not `None`, must be a dictionary that will be filled with a mapping from `_FeatureColumn` to associated list of `Variable`s. For example, after the call, we might have cols_to_vars = { _NumericColumn( key='numeric_feature1', shape=(1,): [], 'bias': [], _NumericColumn( key='numeric_feature2', shape=(2,)): []} If a column creates no variables, its value will be an empty list. Note that cols_to_vars will also contain a string key 'bias' that maps to a list of Variables. Returns: A `Tensor` which represents predictions/logits of a linear model. Its shape is (batch_size, units) and its dtype is `float32`. Raises: ValueError: if an item in `feature_columns` is neither a `_DenseColumn` nor `_CategoricalColumn`. N linear_model)rQunitssparse_combinerr3r4r')r_strip_leading_slashesr' _LinearModelupdaterP) rRrQrrr3r4rPvs model_namelinear_model_layerretvals r*rrsx$$T>:1b'0J1#% %+   h '&*779: -11s A11A:c|D]w}|tjjk(r!t|tj r't |D]}tj||btj||yy)zAdds a var to the list of weight_collections provided. Handles the case for partitioned and non-partitioned variables. Args: var: A variable or Partitioned Variable. weight_collections: List of collections to add variable to. N)rrCrDrXrPartitionedVariabler\add_to_collection)varr3weight_collectionconstituent_vars r*_add_to_collectionsrst. 4CMM:::#y445!#YB/ /AB -s3 4r-c:eZdZdZ dfd ZdZdZxZS)_FCLinearWrapperz\Wraps a _FeatureColumn in a layer for use in a linear model. See `linear_model` above. c jtt| d||d|||_||_||_||_yNr4r'r)superrrp_feature_column_units_sparse_combinerrg) rnfeature_columnrrr3r4r'kwargs __class__s r*rpz_FCLinearWrapper.__init__sF D*2$2*02)DDK+D1Dr-ct|jtrR|jd|jj|j ft j|j}na|jjj}|jd||j gt j|j}t||j||_ d|_y)Nr)r'r6 initializerr4T)rXr_CategoricalColumn add_variable _num_bucketsrrzeros_initializerr4r?r@rrg _weight_varbuilt)rn_weightr@s r*buildz_FCLinearWrapper.builds$&&(:;  %%22DKK@002NN !$f ))99FFHl  t{{+002NN !$f  8 89DDJr-c t|j||j|j|j|j |j }|S)NrKrHrrr3r4 weight_var)_create_weighted_sumrrrrgr4r)rnrH weighted_sums r*callz_FCLinearWrapper.callsI'##kk--33..##%L r-r9sumNTNrrrrrprr __classcell__rs@r*rrs($"& 2$ r-rc8eZdZdZ dfd ZdZdZxZS) _BiasLayerzA layer for the bias term.c Ntt| d||d|||_||_yr)rrrprrg)rnrr4r3r'rrs r*rpz_BiasLayer.__init__s-  *d$NytNvNDK1Dr-c|jd|jgtj|j|_t |j |jd|_y)N bias_weights)r6rr4T) rrrrr4_bias_variablerrgrrnrs r*rz_BiasLayer.buildsX++{{m..0.. ,"D ++T-E-EFDJr-c|jSr%)rrs r*rz_BiasLayer.calls   r-)r9TNNrrs@r*rrs#""& 2r-rc|t|tjstj|r|gSt |Sr%)rXrVariableris_resource_variabler\)variables r*_get_expanded_variable_listrs29--.00: : >r-c,|jdddS)N/r9)rsplitr&s r*rrs S! R  r-c@eZdZdZ dfd ZdZdZdZxZS)rzSCreates a linear model using feature columns. See `linear_model` for details. c vtt| dd|i|d|_t ||_t |xsg|_tjj|jvr3|jjtjjtjj|jvr3|jjtjji}t|j dD]a} tjd| j5} t!| j"} dddt%| |||j| fi|} | || <c|j'||_t+d|||jdd||_i|_y#1swYhxYw) Nr'Tc|jSr%r&r(s r*r+z'_LinearModel.__init__../s affr-r.r0 bias_layer)rr4r3r'r)rrrp _keras_stylerWrfr\rgrrCrDr<r]r;rr=rr'r _add_layers_column_layersr _bias_layerri)rnrQrrr3r4r'r column_layersrKr column_name column_layerrs r*rpz_LinearModel.__init__s ,&;D;F; D6GD#$6$<"=D }}%%T-E-EE %%cmm&D&DE }}$$D,D,DD %%cmm&C&CDM..4DE 0  ( ( V33 568:-RWW5 6 &fe_&*&>&> &1=5;=l$0mK  0**=9D!33    D D#66s 2F//F8 c|jS)zReturns a dict mapping _FeatureColumns to variables. See `linear_model` for more information. This is not populated till `call` is called i.e. layer is built. )rirus r*rPz_LinearModel.cols_to_varsCs   r-c |tj|j5|jD]2}t|tt frt dj|g}g}t|}t|jjdD]~}|j}|j|||}|j|tjtj j"|j$|j&|<t)||t+j,|d}t/j0||j3|tj4d} |j2j6d} t9| |j&d <ddd| S#1swY SxYw) NzWItems of feature_columns must be either a _DenseColumn or _CategoricalColumn. Given: {}c|jSr%r&r(s r*r+z#_LinearModel.call..Us affr-r.r7weighted_sum_no_biasr&rrbias)rr'rfrXrYrrZr[r:r;rrVrr<rrBrCrD scope_namerirFradd_nrbias_addrrErr) rnrRrK weighted_sumsrJrHlayerrpredictions_no_bias predictionsrs r*rz_LinearModel.callKs  & &tyy 1E))N&&<1C"DE>>DfVnN NN moX&g$--446t#Dd 7E8 9E8 s&F1E F11F;cV|jD]\}}t|d|z||S)Nzlayer-%s)itemssetattr)rnlayersr'rs r*rz_LinearModel._add_layersjs3||~. e dJ%u-. Mr-r) rrrrrprPrrrrs@r*rrs.$"& )V>r-rcjt|}i}tjdd|j5t |}t |dD]@}tjd|j 5|j|||<dddB ddd|S#1swYWxYw#1swY|SxYw)aReturns transformed features based on features columns passed in. Please note that most probably you would not need to use this function. Please check `input_layer` and `linear_model` to see whether they will satisfy your use case or not. Example: ```python # Define features and transformations crosses_a_x_b = crossed_column( columns=["sparse_feature_a", "sparse_feature_b"], hash_bucket_size=10000) price_buckets = bucketized_column( source_column=numeric_column("price"), boundaries=[...]) columns = [crosses_a_x_b, price_buckets] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) transformed = transform_features(features=features, feature_columns=columns) assertCountEqual(columns, transformed.keys()) ``` Args: features: A mapping from key to tensors. `_FeatureColumn`s look up via these keys. For example `numeric_column('price')` will look at 'price' key in this dict. Values can be a `SparseTensor` or a `Tensor` depends on corresponding `_FeatureColumn`. feature_columns: An iterable containing all the `_FeatureColumn`s. Returns: A `dict` mapping `_FeatureColumn` to `Tensor` and `SparseTensor` values. Ntransform_featuresrUc|jSr%r&r(s r*r+z%_transform_features..r,r-r.r0)rWr name_scoperVr:r;r'get)rRrQoutputsrHrKs r*_transform_featuresrssB/?/ ' ~~ -hoo6GI.8$G.>?. >>$V[[ 9.!++f-.... ... . .s#>B(2B B(B% !B((B2z&feature_column.make_parse_example_specc 8i}|D]}t|tstdj||j}t j |D]1\}}||vs |||k7stdj|||||j||S)aaCreates parsing spec dictionary from input feature_columns. The returned dictionary can be used as arg 'features' in `tf.io.parse_example`. Typical usage example: ```python # Define features and transformations feature_a = categorical_column_with_vocabulary_file(...) feature_b = numeric_column(...) feature_c_bucketized = bucketized_column(numeric_column("feature_c"), ...) feature_a_x_feature_c = crossed_column( columns=["feature_a", feature_c_bucketized], ...) feature_columns = set( [feature_b, feature_c_bucketized, feature_a_x_feature_c]) features = tf.io.parse_example( serialized=serialized_examples, features=make_parse_example_spec(feature_columns)) ``` For the above example, make_parse_example_spec would return the dict: ```python { "feature_a": parsing_ops.VarLenFeature(tf.string), "feature_b": parsing_ops.FixedLenFeature([1], dtype=tf.float32), "feature_c": parsing_ops.FixedLenFeature([1], dtype=tf.float32) } ``` Args: feature_columns: An iterable containing all feature columns. All items should be instances of classes derived from `_FeatureColumn`. Returns: A dict mapping each feature key to a `FixedLenFeature` or `VarLenFeature` value. Raises: ValueError: If any of the given `feature_columns` is not a `_FeatureColumn` instance. z?All feature_columns must be _FeatureColumn instances. Given: {}zHfeature_columns contain different parse_spec for key {}. Given {} and {})rX_FeatureColumnrZr[_parse_example_specsix iteritemsr)rQresultrKconfigr/values r*make_parse_example_specrs` & f fn - ##)6&> 33  ' 'FmmF+P U 5F3K///5vc5&+/NP PP MM&  -r-c  ||dkrtdj||du|duk7r td/ts$tdj|j-t j ddt j|z |j|f fd} t|||| |||| S) a> `_DenseColumn` that converts from sparse, categorical input. Use this when your inputs are sparse, but you want to convert them to a dense representation (e.g., to feed to a DNN). Inputs must be a `_CategoricalColumn` created by any of the `categorical_column_*` function. Here is an example of using `embedding_column` with `DNNClassifier`: Args: categorical_column: A `_CategoricalColumn` created by a `categorical_column_with_*` function. This column produces the sparse IDs that are inputs to the embedding lookup. dimension: An integer specifying dimension of the embedding, must be > 0. combiner: A string specifying how to reduce if there are multiple entries in a single row. Currently 'mean', 'sqrtn' and 'sum' are supported, with 'mean' the default. 'sqrtn' often achieves good accuracy, in particular with bag-of-words columns. Each of this can be thought as example level normalizations on the column. For more information, see `tf.embedding_lookup_sparse`. initializer: A variable initializer function to be used in embedding variable initialization. If not specified, defaults to `tf.compat.v1.truncated_normal_initializer` with mean `0.0` and standard deviation `1/sqrt(dimension)`. ckpt_to_load_from: String representing checkpoint name/pattern from which to restore column weights. Required if `tensor_name_in_ckpt` is not `None`. tensor_name_in_ckpt: Name of the `Tensor` in `ckpt_to_load_from` from which to restore the column weights. Required if `ckpt_to_load_from` is not `None`. max_norm: If not `None`, embedding values are l2-normalized to this value. trainable: Whether or not the embedding is trainable. Default is True. use_safe_embedding_lookup: If true, uses safe_embedding_lookup_sparse instead of embedding_lookup_sparse. safe_embedding_lookup_sparse ensures there are no empty rows and all weights and ids are positive at the expense of extra compute cost. This only applies to rank 2 (NxM) shaped input tensors. Defaults to true, consider turning off if the above checks are not needed. Note that having empty rows will not trigger any error though the output result might be 0 or omitted. Returns: `_DenseColumn` that converts from sparse input. Raises: ValueError: if `dimension` not > 0. ValueError: if exactly one of `ckpt_to_load_from` and `tensor_name_in_ckpt` is specified. ValueError: if `initializer` is specified and is not callable. RuntimeError: If eager execution is enabled. Nr9zInvalid dimension {}.zPMust specify both `ckpt_to_load_from` and `tensor_name_in_ckpt` or none of them.zGinitializer must be callable if specified. Embedding of column_name: {})meanstddevc8t|d}|d|S)Nembedding_column_layer)embedding_shaperr3r4r'r7)_EmbeddingColumnLayer)r3r8rrrr4s r*_creatorz#_embedding_column.._creator's,2'- % ' "$e 44r- categorical_column dimensioncombiner layer_creatorckpt_to_load_fromtensor_name_in_ckptmax_normr4use_safe_embedding_lookup) rZr[callabler'rtruncated_normal_initializermathsqrtr_EmbeddingColumn) rrrrrrrr4r rrs ` ` @r*_embedding_columnrstY] ,33I> ??4%8D%@A > ??(= 44:F+0052 3377 TYYy113K'33Y>/5 +)- 9 ; ;r-)r9cHt||}|js'|jstdj ||t j ||||}|%t|stdj |t j|t|||||S)a Represents real valued or numerical features. Example: ```python price = numeric_column('price') columns = [price, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) dense_tensor = input_layer(features, columns) # or bucketized_price = bucketized_column(price, boundaries=[...]) columns = [bucketized_price, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction = linear_model(features, columns) ``` Args: key: A unique string identifying the input feature. It is used as the column name and the dictionary key for feature parsing configs, feature `Tensor` objects, and feature columns. shape: An iterable of integers specifies the shape of the `Tensor`. An integer can be given which means a single dimension `Tensor` with given width. The `Tensor` representing the column will have the shape of [batch_size] + `shape`. default_value: A single value compatible with `dtype` or an iterable of values compatible with `dtype` which the column takes on during `tf.Example` parsing if data is missing. A default value of `None` will cause `tf.io.parse_example` to fail if an example does not contain this column. If a single value is provided, the same value will be applied as the default value for every item. If an iterable of values is provided, the shape of the `default_value` should be equal to the given `shape`. dtype: defines the type of values. Default value is `tf.float32`. Must be a non-quantized, real integer or floating point type. 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 `_NumericColumn`. Raises: TypeError: if any dimension in shape is not an int ValueError: if any dimension in shape is not a positive integer TypeError: if `default_value` is an iterable but not compatible with `shape` TypeError: if `default_value` is not compatible with `dtype`. ValueError: if `dtype` is not convertible to `tf.float32`. z6dtype must be convertible to float. dtype: {}, key: {}z+normalizer_fn must be a callable. Given: {})r6 default_valuedtype normalizer_fn) _check_shape is_integer is_floatingrZr[fc_utilscheck_default_valuer  TypeErrorassert_key_is_string_NumericColumnr/r6rrrs r*_numeric_columnr<sp uc "%   e// **0&*< >>..umUCP-x '> 5<<]K MM $  ! !  ##r-ct|tstdj|t |j dkDrtdj||r t|t st|ts tdtt |dz D]}||||dzk\stdt|t|S)aRepresents discretized dense input. Buckets include the left boundary, and exclude the right boundary. Namely, `boundaries=[0., 1., 2.]` generates buckets `(-inf, 0.)`, `[0., 1.)`, `[1., 2.)`, and `[2., +inf)`. For example, if the inputs are ```python boundaries = [0, 10, 100] input tensor = [[-5, 10000] [150, 10] [5, 100]] ``` then the output will be ```python output = [[0, 3] [3, 2] [1, 3]] ``` Example: ```python price = numeric_column('price') bucketized_price = bucketized_column(price, boundaries=[...]) columns = [bucketized_price, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction = linear_model(features, columns) # or columns = [bucketized_price, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) dense_tensor = input_layer(features, columns) ``` A `bucketized_column` can also be crossed with another categorical column using `crossed_column`: ```python price = numeric_column('price') # bucketized_column converts numerical feature to a categorical one. bucketized_price = bucketized_column(price, boundaries=[...]) # 'keywords' is a string feature. price_x_keywords = crossed_column([bucketized_price, 'keywords'], 50K) columns = [price_x_keywords, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction = linear_model(features, columns) ``` Args: source_column: A one-dimensional dense column which is generated with `numeric_column`. boundaries: A sorted list or tuple of floats specifying the boundaries. Returns: A `_BucketizedColumn`. Raises: ValueError: If `source_column` is not a numeric column, or if it is not one-dimensional. ValueError: If `boundaries` is not a sorted list or tuple. zIsource_column must be a column generated with numeric_column(). Given: {}r9z7source_column must be one-dimensional column. Given: {}z!boundaries must be a sorted list.) rXrrZr[lenr6r\tuplerange_BucketizedColumn) source_column boundariesis r*_bucketized_columnr&sD M> 2  F=) ++   ! !!' !6 88  j$ ':j%+H 8 99 Z1$ % 1. The number of buckets. dtype: The type of features. Only string and integer types are supported. Returns: A `_HashedCategoricalColumn`. Raises: ValueError: `hash_bucket_size` is not greater than 1. ValueError: `dtype` is neither string nor integer. z%hash_bucket_size must be set. key: {}r9zBhash_bucket_size must be at least 1. hash_bucket_size: {}, key: {}column_name: {}prefix)rZr[rrassert_string_or_int_HashedCategoricalColumnr/hash_bucket_sizers r*$_categorical_column_with_hash_bucketr/sX ?FFsK LL 55;V)360 11 $ .?.F.Fs.KL !#'7 ??r-c|stdj||wtj|stdj|tj|5}t d|D}dddt jd||||dkrtdj||r<|tdj||d krtd j||tj|d j| tj|t||||d n||d |S||S#1swYxYw)a A `_CategoricalColumn` with a vocabulary file. Use this when your inputs are in string or integer format, and you have a vocabulary file that maps each value to an integer ID. By default, out-of-vocabulary values are ignored. Use either (but not both) of `num_oov_buckets` and `default_value` to specify how to include out-of-vocabulary values. For input dictionary `features`, `features[key]` is either `Tensor` or `SparseTensor`. If `Tensor`, missing values can be represented by `-1` for int and `''` for string, which will be dropped by this feature column. Example with `num_oov_buckets`: File '/us/states.txt' contains 50 lines, each with a 2-character U.S. state abbreviation. All inputs with values in that file are assigned an ID 0-49, corresponding to its line number. All other values are hashed and assigned an ID 50-54. ```python states = categorical_column_with_vocabulary_file( key='states', vocabulary_file='/us/states.txt', vocabulary_size=50, num_oov_buckets=5) columns = [states, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction = linear_model(features, columns) ``` Example with `default_value`: File '/us/states.txt' contains 51 lines - the first line is 'XX', and the other 50 each have a 2-character U.S. state abbreviation. Both a literal 'XX' in input, and other values missing from the file, will be assigned ID 0. All others are assigned the corresponding line number 1-50. ```python states = categorical_column_with_vocabulary_file( key='states', vocabulary_file='/us/states.txt', vocabulary_size=51, default_value=0) columns = [states, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction, _, _ = linear_model(features, columns) ``` And to make an embedding with either: ```python columns = [embedding_column(states, 3),...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) dense_tensor = input_layer(features, columns) ``` Args: key: A unique string identifying the input feature. It is used as the column name and the dictionary key for feature parsing configs, feature `Tensor` objects, and feature columns. 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 `_CategoricalColumn` with a vocabulary file. 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. zMissing vocabulary_file in {}.Nz%vocabulary_file in {} does not exist.c3 K|]}dyw)r9Nr).0rs r* z;_categorical_column_with_vocabulary_file..os>!A>s z]vocabulary_size = %d in %s is inferred from the number of elements in the vocabulary_file %s.r9zInvalid vocabulary_size in {}.;Can't specify both num_oov_buckets and default_value in {}.r!Invalid num_oov_buckets {} in {}.r(r)r)r/vocabulary_filevocabulary_sizenum_oov_bucketsrr) rZr[rExistsGFilerlogginginforr+r _VocabularyFileCategoricalColumn)r/r6r7r8rrfs r*(_categorical_column_with_vocabulary_filer?slh  5<EEcJ KK _ %*>q>)o* LL %&5sOM q 5<dtype {} and vocabulary dtype {} do not match, column_name: {}r(r/vocabulary_listrrr8)rrZr[setras_dtypenparrayrrr+rr _VocabularyListCategoricalColumnr )r/rBrrr8vocabulary_dtypes r*(_categorical_column_with_vocabulary_listrIs`3#7!#; ?FF S " ## _ #o"66 ?FF S " ##__RXXo%>%D%DE  H O O   :AA 3  !! ;BB3GI ] E +666 HOO #S * ++ .?.F.Fs.KL $ ) O, !%  ''r-c|dkrtdj|||&|dks||k\rtdj|||tj|t |||S)aA `_CategoricalColumn` that returns identity values. Use this when your inputs are integers in the range `[0, num_buckets)`, and you want to use the input value itself as the categorical ID. Values outside this range will result in `default_value` if specified, otherwise it will fail. Typically, this is used for contiguous ranges of integer indexes, but it doesn't have to be. This might be inefficient, however, if many of IDs are unused. Consider `categorical_column_with_hash_bucket` in that case. For input dictionary `features`, `features[key]` is either `Tensor` or `SparseTensor`. If `Tensor`, missing values can be represented by `-1` for int and `''` for string, which will be dropped by this feature column. In the following examples, each input in the range `[0, 1000000)` is assigned the same value. All other inputs are assigned `default_value` 0. Note that a literal 0 in inputs will result in the same default ID. Linear model: ```python video_id = categorical_column_with_identity( key='video_id', num_buckets=1000000, default_value=0) columns = [video_id, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction, _, _ = linear_model(features, columns) ``` Embedding for a DNN model: ```python columns = [embedding_column(video_id, 9),...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) dense_tensor = input_layer(features, columns) ``` Args: key: A unique string identifying the input feature. It is used as the column name and the dictionary key for feature parsing configs, feature `Tensor` objects, and feature columns. num_buckets: Range of inputs and outputs is `[0, num_buckets)`. default_value: If set, values outside of range `[0, num_buckets)` will be replaced with this value. If not set, values >= num_buckets will cause a failure while values < 0 will be dropped. Returns: A `_CategoricalColumn` that returns identity values. Raises: ValueError: if `num_buckets` is less than one. ValueError: if `default_value` is not in range `[0, num_buckets)`. r9z"num_buckets {} < 1, column_name {}rz5default_value {} not in range [0, {}), column_name {}r/ num_bucketsr)rZr[rr_IdentityCategoricalColumnrKs r*!_categorical_column_with_identityrNsl1_ 9@@S }q'8'4 'C ?FF ; - .. $ # ;m EEr-ct|S)aRepresents multi-hot representation of given categorical column. - For DNN model, `indicator_column` can be used to wrap any `categorical_column_*` (e.g., to feed to DNN). Consider to Use `embedding_column` if the number of buckets/unique(values) are large. - For Wide (aka linear) model, `indicator_column` is the internal representation for categorical column when passing categorical column directly (as any element in feature_columns) to `linear_model`. See `linear_model` for details. ```python name = indicator_column(categorical_column_with_vocabulary_list( 'name', ['bob', 'george', 'wanda']) columns = [name, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) dense_tensor = input_layer(features, columns) dense_tensor == [[1, 0, 0]] # If "name" bytes_list is ["bob"] dense_tensor == [[1, 0, 1]] # If "name" bytes_list is ["bob", "wanda"] dense_tensor == [[2, 0, 0]] # If "name" bytes_list is ["bob", "bob"] ``` Args: categorical_column: A `_CategoricalColumn` which is created by `categorical_column_with_*` or `crossed_column` functions. Returns: An `_IndicatorColumn`. )_IndicatorColumn)rs r*_indicator_columnrQAs> , --r-c||js&|jstdj|t |||S)aApplies weight values to a `_CategoricalColumn`. Use this when each of your sparse inputs has both an ID and a value. For example, if you're representing text documents as a collection of word frequencies, you can provide 2 parallel sparse input features ('terms' and 'frequencies' below). Example: Input `tf.Example` objects: ```proto [ features { feature { key: "terms" value {bytes_list {value: "very" value: "model"}} } feature { key: "frequencies" value {float_list {value: 0.3 value: 0.1}} } }, features { feature { key: "terms" value {bytes_list {value: "when" value: "course" value: "human"}} } feature { key: "frequencies" value {float_list {value: 0.4 value: 0.1 value: 0.2}} } } ] ``` ```python categorical_column = categorical_column_with_hash_bucket( column_name='terms', hash_bucket_size=1000) weighted_column = weighted_categorical_column( categorical_column=categorical_column, weight_feature_key='frequencies') columns = [weighted_column, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction, _, _ = linear_model(features, columns) ``` This assumes the input dictionary contains a `SparseTensor` for key 'terms', and a `SparseTensor` for key 'frequencies'. These 2 tensors must have the same indices and dense shape. Args: categorical_column: A `_CategoricalColumn` created by `categorical_column_with_*` functions. weight_feature_key: String key for weight values. dtype: Type of weights, such as `tf.float32`. Only float and integer weights are supported. Returns: A `_CategoricalColumn` composed of two sparse features: one represents id, the other represents weight (value) of the id feature in that example. Raises: ValueError: if `dtype` is not convertible to float. z%dtype {} is not convertible to float.rweight_feature_keyr)rrrZr[_WeightedCategoricalColumnrSs r*_weighted_categorical_columnrVcsGF mU--1B1B <CCEJ KK #++  r-c|r|dkrtdj||rt|dkrtdj||D]p}t|tj s*t|t stdj|t|tsXtdj|tt|||S)a Returns a column for performing crosses of categorical features. Crossed features are hashed according to `hash_bucket_size`. Conceptually, the transformation can be thought of as: Hash(cartesian product of features) % `hash_bucket_size` For example, if the input features are: * SparseTensor referred by first key: ```python shape = [2, 2] { [0, 0]: "a" [1, 0]: "b" [1, 1]: "c" } ``` * SparseTensor referred by second key: ```python shape = [2, 1] { [0, 0]: "d" [1, 0]: "e" } ``` then crossed feature will look like: ```python shape = [2, 2] { [0, 0]: Hash64("d", Hash64("a")) % hash_bucket_size [1, 0]: Hash64("e", Hash64("b")) % hash_bucket_size [1, 1]: Hash64("e", Hash64("c")) % hash_bucket_size } ``` Here is an example to create a linear model with crosses of string features: ```python keywords_x_doc_terms = crossed_column(['keywords', 'doc_terms'], 50K) columns = [keywords_x_doc_terms, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction = linear_model(features, columns) ``` You could also use vocabulary lookup before crossing: ```python keywords = categorical_column_with_vocabulary_file( 'keywords', '/path/to/vocabulary/file', vocabulary_size=1K) keywords_x_doc_terms = crossed_column([keywords, 'doc_terms'], 50K) columns = [keywords_x_doc_terms, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction = linear_model(features, columns) ``` If an input feature is of numeric type, you can use `categorical_column_with_identity`, or `bucketized_column`, as in the example: ```python # vertical_id is an integer categorical feature. vertical_id = categorical_column_with_identity('vertical_id', 10K) price = numeric_column('price') # bucketized_column converts numerical feature to a categorical one. bucketized_price = bucketized_column(price, boundaries=[...]) vertical_id_x_price = crossed_column([vertical_id, bucketized_price], 50K) columns = [vertical_id_x_price, ...] features = tf.io.parse_example(..., features=make_parse_example_spec(columns)) linear_prediction = linear_model(features, columns) ``` To use crossed column in DNN model, you need to add it in an embedding column as in this example: ```python vertical_id_x_price = crossed_column([vertical_id, bucketized_price], 50K) vertical_id_x_price_embedded = embedding_column(vertical_id_x_price, 10) dense_tensor = input_layer(features, [vertical_id_x_price_embedded, ...]) ``` Args: keys: An iterable identifying the features to be crossed. Each element can be either: * string: Uses the corresponding feature which must be of string type. * `_CategoricalColumn`: Uses the transformed tensor produced by this column. Does not support hashed categorical column. hash_bucket_size: An int > 1. The number of buckets. hash_key: Specify the hash_key that will be used by the `FingerprintCat64` function to combine the crosses fingerprints on SparseCrossOp (optional). Returns: A `_CrossedColumn`. Raises: ValueError: If `len(keys) < 2`. ValueError: If any of the keys is neither a string nor `_CategoricalColumn`. ValueError: If any of the keys is `_HashedCategoricalColumn`. ValueError: If `hash_bucket_size < 1`. r9z2hash_bucket_size must be > 1. hash_bucket_size: {}z.keys must be a list with length > 1. Given: {}zvUnsupported key type. All keys must be either string, or categorical column except _HashedCategoricalColumn. Given: {}zcategorical_column_with_hash_bucket is not supported for crossing. Hashing before crossing will increase probability of collision. Instead, use the feature name as a string. Given: {}keysr.hash_key) rZr[rrXr string_typesrr,_CrossedColumnr )rZr.r[r/s r*_crossed_columnr^sP -1 ,,2F3C,D FF TQ 8??E GG  Nc sC,, - s. /  fSk ###/0  AAG NN N  ;)9H NNr-c<eZdZdZ dfd ZdZdZdZxZS)rzBA layer that stores all the state required for a embedding column.c \tt| d||d|||_||_||_y)aConstructor. Args: embedding_shape: Shape of the embedding variable used for lookup. initializer: A variable initializer function to be used in embedding variable initialization. weight_collections: A list of collection names to which the Variable will be added. Note that, variables will also be added to collections `tf.GraphKeys.GLOBAL_VARIABLES` and `ops.GraphKeys.MODEL_VARIABLES`. trainable: If `True` also add the variable to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). name: Name of the layer **kwargs: keyword named properties. rNr)rrrp_embedding_shape _initializerrg)rnrrr3r4r'rrs r*rpz_EmbeddingColumnLayer.__init__0s?* /2$2*02+D#D1Dr-c||_y)zSets the weight collections for the layer. Args: weight_collections: A list of collection names to which the Variable will be added. N)rg)rnr3s r*set_weight_collectionsz,_EmbeddingColumnLayer.set_weight_collectionsKs  2Dr-c |jd|jtj|j|j |_|jr4tjs t|j |jd|_ y)Nembedding_weights)r'r6rrr4T) rrarfloat32rbr4_embedding_weight_varrgrexecuting_eagerlyrrrs r*rz_EmbeddingColumnLayer.buildTsp!%!2!2 ##nn%%.. "3""D  (A(A(C$44d6N6NODJr-c|jSr%)rhrs r*rz_EmbeddingColumnLayer.call_s  % %%r-)NTN) rrrrrprdrrrrs@r*rr-s%J #' 262 &r-rceZdZdZej dZdZdZe dZ ejdZ ej dZ dZy ) raWRepresents a feature column abstraction. WARNING: Do not subclass this layer unless you know what you are doing: the API is subject to future changes. To distinguish the concept of a feature family and a specific binary feature within a family, we refer to a feature family like "country" as a feature column. Following is an example feature in a `tf.Example` format: {key: "country", value: [ "US" ]} In this example the value of feature is "US" and "country" refers to the column of the feature. This class is an abstract class. User should not create instances of this. cy)z3Returns string. Used for naming and for name_scope.Nrrus r*r'z_FeatureColumn.namet r-c0t|t|kS)a8Allows feature columns to be sorted in Python 3 as they are in Python 2. Feature columns need to occasionally be sortable, for example when used as keys in a features dictionary passed to a layer. In CPython, `__lt__` must be defined for all objects in the sequence being sorted. If any objects do not have an `__lt__` compatible with feature column objects (such as strings), then CPython will fall back to using the `__gt__` method below. https://docs.python.org/3/library/stdtypes.html#list.sort Args: other: The other object to compare to. Returns: True if the string representation of this object is lexicographically less than the string representation of `other`. For FeatureColumn objects, this looks like "<__main__.FeatureColumn object at 0xa>". strrnothers r*__lt__z_FeatureColumn.__lt__ys( t9s5z !!r-c0t|t|kDS)aAllows feature columns to be sorted in Python 3 as they are in Python 2. Feature columns need to occasionally be sortable, for example when used as keys in a features dictionary passed to a layer. `__gt__` is called when the "other" object being compared during the sort does not have `__lt__` defined. Example: ``` # __lt__ only class class A(): def __lt__(self, other): return str(self) < str(other) a = A() a < "b" # True "0" < a # Error # __lt__ and __gt__ class class B(): def __lt__(self, other): return str(self) < str(other) def __gt__(self, other): return str(self) > str(other) b = B() b < "c" # True "0" < b # True ``` Args: other: The other object to compare to. Returns: True if the string representation of this object is lexicographically greater than the string representation of `other`. For FeatureColumn objects, this looks like "<__main__.FeatureColumn object at 0xa>". rorqs r*__gt__z_FeatureColumn.__gt__sJ t9s5z !!r-c|jS)z?Returns string. Used for variable_scope. Defaults to self.name.r&rus r*r=z_FeatureColumn._var_scope_names 99r-cy)a]Returns intermediate representation (usually a `Tensor`). Uses `inputs` to create an intermediate representation (usually a `Tensor`) that other feature columns can use. Example usage of `inputs`: Let's say a Feature column depends on raw feature ('raw') and another `_FeatureColumn` (input_fc). To access corresponding `Tensor`s, inputs will be used as follows: ```python raw_tensor = inputs.get('raw') fc_tensor = inputs.get(input_fc) ``` Args: inputs: A `_LazyBuilder` object to access inputs. Returns: Transformed feature `Tensor`. Nrrninputss r*_transform_featurez!_FeatureColumn._transform_feature. r-cy)axReturns a `tf.Example` parsing spec as dict. It is used for get_parsing_spec for `tf.io.parse_example`. Returned spec is a dict from keys ('string') to `VarLenFeature`, `FixedLenFeature`, and other supported objects. Please check documentation of `tf.io.parse_example` for all supported spec objects. Let's say a Feature column depends on raw feature ('raw') and another `_FeatureColumn` (input_fc). One possible implementation of _parse_example_spec is as follows: ```python spec = {'raw': tf.io.FixedLenFeature(...)} spec.update(input_fc._parse_example_spec) return spec ``` Nrrus r*rz"_FeatureColumn._parse_example_specs& r-cy)zResets the configuration in the column. Some feature columns e.g. embedding or shared embedding columns might have some state that is needed to be reset sometimes. Use this method in that scenario. Nrrus r* _reset_configz_FeatureColumn._reset_configsr-N)rrrrabcabstractpropertyr'rsrurr=abstractmethodrzrr~rr-r*rrcsy   ",%"N    0  (r-rcZeZdZdZej dZejddZy)rYaRepresents a column which can be represented as `Tensor`. WARNING: Do not subclass this layer unless you know what you are doing: the API is subject to future changes. Some examples of this type are: numeric_column, embedding_column, indicator_column. cy)z>`TensorShape` of `_get_dense_tensor`, without batch dimension.Nrrus r*r?z_DenseColumn._variable_shapermr-Ncy)aReturns a `Tensor`. The output of this function will be used by model-builder-functions. For example the pseudo code of `input_layer` will be like: ```python def input_layer(features, feature_columns, ...): outputs = [fc._get_dense_tensor(...) for fc in feature_columns] return tf.concat(outputs) ``` Args: inputs: A `_LazyBuilder` object to access inputs. weight_collections: List of graph collections to which Variables (if any will be created) are added. trainable: If `True` also add variables to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.Variable`). Returns: `Tensor` of shape [batch_size] + `_variable_shape`. Nrrnryr3r4s r*r>z_DenseColumn._get_dense_tensorr{r-NN) rrrrrrr?rr>rr-r*rYrYs;    r-rYc ht|trt|||||||St||||||S)zGCreates a weighted sum for a dense/categorical column for linear_model.r)rKrHrr3r4r)rXr'_create_categorical_column_weighted_sum!_create_dense_column_weighted_sumrs r*rrsR*+ 2'-  --  r-cV|j|||}|jj}tj|d}tj |||f}||} n.t jd||gtj||} tj|| dS)z9Create a weighted sum of a dense column for linear_model.r2rr5rr'r6rr4 collectionsrr&) r>r?r@r r6rAr get_variablerrrmatmul) rKrHrr3r4rrLr@rMrs r*rr6s  # # + $ &''446,v&q)*   VJ +E F& F  ( ( U#..0& (F n ==r-ceZdZdZej dddgZejdZ ej ddZ y) rzRepresents a categorical feature. WARNING: Do not subclass this layer unless you know what you are doing: the API is subject to future changes. A categorical feature typically handled with a `tf.sparse.SparseTensor` of IDs. IdWeightPair id_tensor weight_tensorcy)1Returns number of buckets in this sparse feature.Nrrus r*rz_CategoricalColumn._num_buckets]rmr-Ncy)aReturns an IdWeightPair. `IdWeightPair` is a pair of `SparseTensor`s which represents ids and weights. `IdWeightPair.id_tensor` is typically a `batch_size` x `num_buckets` `SparseTensor` of `int64`. `IdWeightPair.weight_tensor` is either a `SparseTensor` of `float` or `None` to indicate all weights should be taken to be 1. If specified, `weight_tensor` must have exactly the same shape and indices as `sp_ids`. Expected `SparseTensor` is same as parsing output of a `VarLenFeature` which is a ragged matrix. Args: inputs: A `LazyBuilder` as a cache to get input tensors required to create `IdWeightPair`. weight_collections: List of graph collections to which variables (if any will be created) are added. trainable: If `True` also add variables to the graph collection `GraphKeys.TRAINABLE_VARIABLES` (see `tf.compat.v1.get_variable`). Nrrs r*_get_sparse_tensorsz&_CategoricalColumn._get_sparse_tensorsbs2 r-r) rrrrr namedtuplerrrrrrrr-r*rrPsa(''{O46,  .2$(  r-rc|j|||}tj|jt j |jddg}|j } | .tj| t j | ddg} ||} n8tjd|j|ftj||} tj| || |dS)aCreate a weighted sum of a categorical column for linear_model. Note to maintainer: As implementation details, the weighted sum is implemented via embedding_lookup_sparse toward efficiency. Mathematically, they are the same. To be specific, conceptually, categorical column can be treated as multi-hot vector. Say: ```python x = [0 0 1] # categorical column input w = [a b c] # weights ``` The weighted sum is `c` in this case, which is same as `w[2]`. Another example is ```python x = [0 1 1] # categorical column input w = [a b c] # weights ``` The weighted sum is `b + c` in this case, which is same as `w[2] + w[3]`. For both cases, we can implement weighted sum via embedding_lookup with sparse_combiner = "sum". r2rrrrr)sparse_weightsrr')rrsparse_reshaperr r6rrrrrrrsafe_embedding_lookup_sparse) rKrHrrr3r4rsparse_tensorsrrrs r*rr~sF-- +..''~//03R8:)!..---  6q92>@M F  ( ( ""E*..0& (F  3 3 "   r-cdeZdZdZej dddgZej ddZ y)_SequenceDenseColumnzRepresents dense sequence data.TensorSequenceLengthPair dense_tensorsequence_lengthNcy)z%Returns a `TensorSequenceLengthPair`.Nrrs r*_get_sequence_dense_tensorz/_SequenceDenseColumn._get_sequence_dense_tensors  r-r) rrrrrrrrrrrr-r*rrsF'3[33 >3D"EG59+/  r-rc"eZdZdZdZdZdZy)r:aHandles caching of transformations while building the model. `_FeatureColumn` specifies how to digest an input column to the network. Some feature columns require data transformations. This class caches those transformations. Some features may be used in more than one place. For example, one can use a bucketized feature by itself and a cross with it. In that case we should create only one bucketization op instead of creating ops for each feature column separately. To handle re-use of transformed columns, `_LazyBuilder` caches all previously transformed columns. Example: We're trying to use the following `_FeatureColumn`s: ```python bucketized_age = fc.bucketized_column(fc.numeric_column("age"), ...) keywords = fc.categorical_column_with_hash_buckets("keywords", ...) age_X_keywords = fc.crossed_column([bucketized_age, "keywords"]) ... = linear_model(features, [bucketized_age, keywords, age_X_keywords] ``` If we transform each column independently, then we'll get duplication of bucketization (one for cross, one for bucketization itself). The `_LazyBuilder` eliminates this duplication. c<|j|_i|_y)aCreates a `_LazyBuilder`. Args: features: A mapping from feature column to objects that are `Tensor` or `SparseTensor`, or can be converted to same via `sparse_tensor.convert_to_tensor_or_sparse_tensor`. A `string` key signifies a base feature (not-transformed). A `_FeatureColumn` key means that this `Tensor` is the output of an existing `_FeatureColumn` which can be reused. N)copy _features_feature_tensorsrrs r*rpz_LazyBuilder.__init__s]]_DNDr-c||jvr|j|S||jvr"|j|}||j|<|St|tj rt dj|t|tstdj||}tjd||j|}|$t dj|j||j|<|S)a&Returns a `Tensor` for the given key. A `str` key is used to access a base feature (not-transformed). When a `_FeatureColumn` is passed, the transformed feature is returned if it already exists, otherwise the given `_FeatureColumn` is asked to provide its transformed output, which is then cached. Args: key: a `str` or a `_FeatureColumn`. Returns: The transformed `Tensor` corresponding to the `key`. Raises: ValueError: if key is not found or a transformed `Tensor` cannot be computed. z)Feature {} is not in features dictionary.z>"key" must be either a "str" or "_FeatureColumn". Provided: {}zTransforming feature_column %s.zColumn {} is not supported.)rr_get_raw_feature_as_tensorrXrr\rZr[rrr;debugrzr')rnr/feature_tensorrK transformeds r*rz_LazyBuilder.gets$ d###  " "3 '' dnn66s;n#1dC #s''( BII#N OO c> * %%+VC[ 22F MM3V<++D1K 4;;FKKH II$/D&! r-c <|j|}tj|djj}|/|dk(rt dj ||dk7rSStjtjtjdj |g5tjtjdtjfdfdcdddS#1swYyxYw) aGets the raw_feature (keyed by `key`) as `tensor`. The raw feature is converted to (sparse) tensor and maybe expand dim. For both `Tensor` and `SparseTensor`, the rank will be expanded (to 2) if the rank is 1. This supports dynamic rank also. For rank 0 raw feature, will error out as it is not supported. Args: key: A `str` key to access the raw feature. Returns: A `Tensor` or `SparseTensor`. Raises: ValueError: if the raw feature has rank 0. ct|tjr.tj|t j |ddgSt j|dS)Nrr9r)rXsparse_tensor_lib SparseTensorrrr r6 expand_dims) input_tensors r*rz<_LazyBuilder._get_raw_feature_as_tensor..expand_dims8sU L"3"@"@ A((*3//,*G*JA)NP P$$\266r-Nrz/Feature (key: {}) cannot have rank 0. Given: {}r9)messagecSr%r)rrsr*r+z9_LazyBuilder._get_raw_feature_as_tensor..Qs +n-r-cSr%r)rsr*r+z9_LazyBuilder._get_raw_feature_as_tensor..Qs~r-)rr"convert_to_tensor_or_sparse_tensor get_shapendimsrZr[rcontrol_dependenciesr assert_positiver rankr requal)rnr/ raw_featurerrrs @@r*rz'_LazyBuilder._get_raw_feature_as_tensor"s $..%K&IIN7  # # % + +D   = D D^ %& & $qy^Ik..II ! !!! NN> *ELL^% &# G YY ..INN>: ; -/EG GGGs ADDN)rrrrrprrrr-r*r:r:s8 (T/Gr-r:cg}t|D]-}|r|j||dz|j|/|j|S)z5Returns moving offset for each dimension given shape.r)reversedr<reverse)r6offsetsdims r*_shape_offsetsrUsO ' e_c nnS72;&' nnS   // .r-c tj|}t|tjr|St j dd||f5|S|j tjk(rd}n3|j jrd}n|j j}tj||j d}tjtj||d}tj|tj ||dtj"|tj$d  cdddS#1swYyxYw) a(Converts a `Tensor` to a `SparseTensor`, dropping ignore_value cells. If `input_tensor` is already a `SparseTensor`, just return it. Args: input_tensor: A string or integer `Tensor`. ignore_value: Entries in `dense_tensor` equal to this value will be absent from the resulting `SparseTensor`. If `None`, default value of `dense_tensor`'s dtype will be used ('' for `str`, -1 for `int`). Returns: A `SparseTensor` with the same shape as `input_tensor`. Raises: ValueError: when `input_tensor`'s rank is `None`. Nto_sparse_inputr ignore_valuer&indicesrV dense_shape)out_typer'rrVr)rrrXrrrrrstringras_numpy_dtypercastr where not_equal gather_ndr6int64)rrrs r*'_to_sparse_input_and_drop_ignore_valuesrbs$"#EE, /<<=  ~~d-0F   v}} ,    ( ( $))88: ==l((~?Loo<6YHG  ) )""<xHOO 6< >?  3396$((3C EE %'' 5l ==v~~ 66r-c@tj|jSr%)r TensorShaper6rus r*r?z_NumericColumn._variable_shapes  # #DJJ //r-Nc(~~|j|S)aReturns dense `Tensor` representing numeric feature. Args: inputs: A `_LazyBuilder` object to access inputs. weight_collections: Unused `weight_collections` since no variables are created in this function. trainable: Unused `trainable` bool since no variables are created in this function. Returns: Dense `Tensor` created within `_transform_feature`. )rrs r*r>z _NumericColumn._get_dense_tensors  ::d r-r) rrrrrr'rrzr?r>rr-r*rrsK     7 0 0r-rrcjeZdZdZedZedZdZedZd dZ edZ d d Z y) r"zSee `bucketized_column`.cLdj|jjS)Nz {}_bucketized)r[r#r'rus r*r'z_BucketizedColumn.names  ! !$"4"4"9"9 ::r-c.|jjSr%)r#rrus r*rz%_BucketizedColumn._parse_example_specs    1 11r-cz|j|j}tj||jS)N)r$)rr#r _bucketizer$)rnry source_tensors r*rzz$_BucketizedColumn._transform_feature s3JJt112M   ?? $$r-ctjt|jjt |j dzfzS)Nr9)rrr r#r6rr$rus r*r?z!_BucketizedColumn._variable_shape sA  # # d  &&'3t+?!+C*EE GGr-Nc~~|j|}tjtj|t j t|jdzddS)Nr9?r)rdepthon_value off_value) rr one_hotrrrrrr$)rnryr3r4rs r*r>z#_BucketizedColumn._get_dense_tensor sR::d#L    lFLL9$//"Q&  r-cft|jdz|jjdzS)Nr9r)rr$r#r6rus r*rz_BucketizedColumn._num_buckets s.  1 $(:(:(@(@(C CCr-c N|j|}tj|d}|jjd}tjtj tj tjd|dd|gd}tj tjd||g}tj|dt|jdz|zz} tjtjtj||ftj } tjtj||gtj } t#j$| | | } t&j)| dS)zDConverts dense inputs to SparseTensor so downstream code can use it.rr9)rrN)rr r6r#rAtilerrr!rr$r transposer stackrrrrrr) rnryr3r4rrMsource_dimensioni1i2bucket_indicesrrrs r*rz%_BucketizedColumn._get_sparse_tensors s] ::d#L.q1J))//2     ! !(..J"? C  ! #$) +B q*:;j\ JB , !$'$81$<#B CmmO112r(;rrrr-r*r"r"sq! ; ; 2 2$  G G D D .2$(@r-r"r#r$c|eZdZdZ d fd ZedZedZdZedZ d dZ d dZ d d Z xZ S) rSee `embedding_column`.c >tt| ||||||||||  S)Nr)rr__new__) clsrrrrrrrr4r rs r*rz_EmbeddingColumn.__new__D s= !3 / -#+/"; 0 = =r-ct|ds*dj|jj|_|jS)Nrjz {}_embeddinghasattrr[rr'rjrus r*r'z_EmbeddingColumn.nameZ s4 4 !!(()@)@)E)EFdj ::r-c.|jjSr%rrrus r*rz$_EmbeddingColumn._parse_example_spec`   " " 6 66r-c8|j|jSr%rrrxs r*rzz#_EmbeddingColumn._transform_featured  ::d-- ..r-c|t|ds%tj|jg|_|jSN_shaperrrrr rus r*r?z _EmbeddingColumn._variable_shapeg / 4 " ,,dnn-=>dk ;;r-c|jj|||}|j}|j}|j |t j }|jX|}t|tjr|j}tj|j|j|itj |j"j%d} t&j(} |j*s| | dkrt&j,} | ||||j.d|j0z|j2S)?Private method that follows the signature of _get_dense_tensor.r2)r3r8rrX %s_weightsrr'r)rrrrrrrErrXrr_get_variable_listrinit_from_checkpointrrdimension_valuerrrrr embedding_lookup_sparse_v2rr'r) rnryr3r4r sparse_idsrrf to_restoresparse_id_rankembedding_lookup_sparses r*_get_dense_tensor_internalz+_EmbeddingColumn._get_dense_tensor_internalm sC ,,@@-AN ))J#11N**-//1+3 )$j J = = >224 ++  4#;#;Z"HJ"11((*1-/N+HH  * *~/I! - H H " DII %   r-ct|jtrCtdj |j t |j|j|j|||SNa6In embedding_column: {}. categorical_column must not be of type _SequenceCategoricalColumn. Suggested fix A: If you wish to use input_layer, use a non-sequence categorical_column_with_*. Suggested fix B: If you wish to create sequence input, use sequence_input_layer instead of input_layer. Given (type {}): {}ryr3r4rXr_SequenceCategoricalColumnrZr[r'rrrs r*r>z"_EmbeddingColumn._get_dense_tensor s$))+EF  !'tyy$t7N7N2O'+'>'>!@ AA  * *- + r-ct|jtsCtdj |j t |j|j|j|||}|jj|}tj|j}tj||SNzIn embedding_column: {}. categorical_column must be of type _SequenceCategoricalColumn to use sequence_input_layer. Suggested fix: Use one of sequence_categorical_column_with_*. Given (type {}): {}rrrrXrrrZr[r'rrrr"sequence_length_from_sparse_tensorrrrrnryr3r4rrrs r*rz+_EmbeddingColumn._get_sequence_dense_tensor s d--/I J  !'tyy$t7N7N2O'+'>'>!@  AA22-3L ,,@@HNAA  "O  8 8!? 9 DDr-)Tr)rrrrrrr'rrzr?rr>rrrs@r*rr; st )-=,    7 7/  59+/% N$59+/Dr-rrc~t|tjrt|djS|jS)Nr)rXrrr\graph)rs r*_get_graph_for_variabler' s0Y223 9Q<   99r-cveZdZdZedZedZedZdZedZ d dZ d d Z d d Z y) _SharedEmbeddingColumnrct|ds*dj|jj|_|jS)Nrjz{}_shared_embeddingrrus r*r'z_SharedEmbeddingColumn.name s4 4 !(//0G0G0L0LMdj ::r-c|jSr%) shared_embedding_collection_namerus r*r=z&_SharedEmbeddingColumn._var_scope_name s  0 00r-c.|jjSr%rrus r*rz*_SharedEmbeddingColumn._parse_example_spec rr-c8|j|jSr%rrxs r*rzz)_SharedEmbeddingColumn._transform_feature rr-c|t|ds%tj|jg|_|jSrr rus r*r?z&_SharedEmbeddingColumn._variable_shape r r-Nc tjd|j5|jj |||}|j }|j }|jj|jf}tj|j}|rt|dkDrtdj||d} | j|k7rtdj|j| j| j|tj d|t"j$|j&|j(xr|| } tj*|j| |j,X| } t/| t0j2r| j5} t7j8|j,|j:| it=j>|j@jd} tBjD} |jFs| | d krtBjH} | | |||jJd |jz|jL cdddS#1swYyxYw) r Nr0r2r9zCollection {} can only contain one variable. Suggested fix A: Choose a unique name for this collection. Suggested fix B: Do not add any variables to this collection. The feature_column library already adds a variable under the hood.raShared embedding collection {} contains variable {} of unexpected shape {}. Expected shape is {}. Suggested fix A: Choose a unique name for this collection. Suggested fix B: Do not add any variables to this collection. The feature_column library already adds a variable under the hood.rf)r'r6rrr4rrXrr)'rrr'rrrrrrrBr,rrZr[rrrrrgrr4rrrXrrrrrrrrrrrr rrr) rnryr3r4rrrrshared_embedding_collectionrfrrrs r*rz1_SharedEmbeddingColumn._get_dense_tensor_internal sT 499 5="..BB /Cn"++j%33n00==t~~No$'$6$6  / /%1! $ * +a /f89 ; ; 8:  & & (O ; fTBB.33.88:OM N N+77$!..((nn2* , dCC/ 1   +& j)"?"? @!446*--  " "T%=%=z$J L$33  * * ,Q /1n - J J,,1K A "/"J"J $   ==dii'== "o="="="s II;;Jct|jtrCtdj |j t |j|j|j|||Srrrs r*r>z(_SharedEmbeddingColumn._get_dense_tensor+ rr-ct|jtsCtdj |j t |j|j|j|||}|jj|}tj|j}tj||Sr r"r$s r*rz1_SharedEmbeddingColumn._get_sequence_dense_tensor; s d--/I J  !'tyy$t7N7N2O'+'>'>!@  AA22-3L,,@@HNAA  "O  8 8!? 9 DDr-r) rrrrrr'r=rrzr?rr>rrr-r*r)r) s|     1 1 7 7/  59+/E"N$59+/Dr-r)) rrrrr,rrrr4r c |Jtj|s|g}t|}|D]W}t|tj st dj|||dks>tdj|||S)z4Returns shape if it's valid, raises error otherwise.z4shape dimensions must be integer. shape: {}, key: {}r9z;shape dimensions must be greater than 0. shape: {}, key: {}) r is_nestedr rXr integer_typesrr[rZ)r6r/rs r*rrR s      GE ,%@i i!2!2 3 ++16%+= ??1} ,,2F5#,> @@ @ ,r-cReZdZdZedZedZdZedZ ddZ y) r,z*see `categorical_column_with_hash_bucket`.c|jSr%r.rus r*r'z_HashedCategoricalColumn.nameh rr-cX|jtj|jiSr%r/r VarLenFeaturerrus r*rz,_HashedCategoricalColumn._parse_example_specl HHk// ; <@ zz 2 2 = ==  88>hh L$6$698 99  zzV]]""))m **<+>+>?m!<<t,,8=  ) ),*>*>*:*6*B*B DDr-c|jSrr.rus r*rz%_HashedCategoricalColumn._num_buckets    r-NcLtj|j|dSr%rrrrs r*rz,_HashedCategoricalColumn._get_sparse_tensors   * *6::d+;T BBr-r rrrrrr'rrzrrrr-r*r,r,b sU3   = =D4 ! ! .2$(Cr-r,r-cReZdZdZedZedZdZedZ ddZ y) r=z.See `categorical_column_with_vocabulary_file`.c|jSr%r.rus r*r'z%_VocabularyFileCategoricalColumn.name rr-cX|jtj|jiSr%r:rus r*rz4_VocabularyFileCategoricalColumn._parse_example_spec r<r-c t|j|j}|jj|jjk7r:t dj |j|j|jtj|jdj |j|j}|jjr4tj}tj|tj}tj|j|j |j"|j$|dj |jj'|S)Nr?r>r) {}_lookup)r6r8 vocab_sizer key_dtyper')rrr/rrrZr[rr+rrrrrindex_table_from_filer6r8r7rr@rnryrrSs r*rzz3_VocabularyFileCategoricalColumn._transform_feature s$:6::dhh;OPL zz 2 2 = ==  88>hh L$6$698 99  !!-44TXX>@ I$$,,i]]<>l  + +,,,,''((    )  + ,26,+? @r-c4|j|jzSrF)r7r8rus r*rz-_VocabularyFileCategoricalColumn._num_buckets s   $"6"6 66r-NcLtj|j|dSr%rJrs r*rz4_VocabularyFileCategoricalColumn._get_sparse_tensors rKr-rrLrr-r*r=r= sU 7   = =@6 7 7 .2$(Cr-r=)r/r6r7r8rrcReZdZdZedZedZdZedZ ddZ y) rGz.See `categorical_column_with_vocabulary_list`.c|jSr%r.rus r*r'z%_VocabularyListCategoricalColumn.name rr-cX|jtj|jiSr%r:rus r*rz4_VocabularyListCategoricalColumn._parse_example_spec r<r-c  t|j|j}|jj|jjk7r:t dj |j|j|jtj|jdj |j|j}|jjr4tj}tj|tj}tjt|j |j"|j$|dj |jj'|S)Nr?r>r)rQ)rBrr8rr')rrr/rrrZr[rr+rrrrrindex_table_from_tensorr rBrr8r@rUs r*rzz3_VocabularyListCategoricalColumn._transform_feature s :6::dhh;OPL zz 2 2 = ==  88>hh L$6$698 99  !!-44TXX>@ I$$,,i]]<>l  - -d223((,,    )  + ,26,+? @r-cFt|j|jzSrF)rrBr8rus r*rz-_VocabularyListCategoricalColumn._num_buckets s  t## $t';'; ;;r-NcLtj|j|dSr%rJrs r*rz4_VocabularyListCategoricalColumn._get_sparse_tensors rKr-rrLrr-r*rGrG sU 7   = =@4 < < .2$(Cr-rGrAcReZdZdZedZedZdZedZ ddZ y) rMz'See `categorical_column_with_identity`.c|jSr%r.rus r*r'z_IdentityCategoricalColumn.name rr-c`|jtjtjiSr%)r/rr;rrrus r*rz._IdentityCategoricalColumn._parse_example_spec s HHk// = >>r-c t|j|j}|jjs/t dj |j|j|j}|jjtjk7r&tj|tjd}|jtj|jtjd}tjdtjd}tjtj ||k||k\dtj"tj$|tj|jtjd |}t'j(|j*||j, S) Nz-Invalid input, not integer. key: {} dtype: {}rVr&rLrzero out_of_rangedefault_values)dimsrr'r)rrr/rrrZr[rVrrrrrrLr r logical_orfillr6rrrr)rnryrrVrLrcs r*rzz-_IdentityCategoricalColumn._transform_feature s[:6::dhh;OPL    ( ( FMM ((L&&( ))  F  FLL0}}VV\\Af %MM   FLL}>k ]]1fll 8d   tmV{2 I ..??6*MM$"4"4fllC# %'- .f  ) )$$ ,, ..r-c|jSrF)rLrus r*rz'_IdentityCategoricalColumn._num_buckets* s   r-NcLtj|j|dSr%rJrs r*rz._IdentityCategoricalColumn._get_sparse_tensors/ rKr-rrLrr-r*rMrM sT0   ? ?.4   .2$(Cr-rMrKcReZdZdZedZedZedZdZ ddZ y) rUz"See `weighted_categorical_column`.cbdj|jj|jS)Nz{}_weighted_by_{})r[rr'rTrus r*r'z_WeightedCategoricalColumn.name= s,  % %d&=&=&B&B&*&=&= ??r-c |jj}|j|vr2tdj ||j|jt j |j||j<|S)Nz&Parse config {} already exists for {}.)rrrTrZr[rr;r)rnrs r*rz._WeightedCategoricalColumn._parse_example_specB sy  $ $ 8 8F &( ?FF (( )4+B+BD EE&1&?&? &KF4 " "# Mr-c.|jjSr%rrrus r*rz'_WeightedCategoricalColumn._num_bucketsK   " " / //r-cN|j|j}|$tdj|jt j |}|j |j jk7r/tdj|j |j t|tjs t|d}|j js$tj|tj}|j|j |fS)NzMissing weights {}.z#Bad dtype, expected {}, but got {}.r)r)rrTrZr[rrr base_dtyperXrrrrrrrgr)rnryrs r*rzz-_WeightedCategoricalColumn._transform_featureO sJJt667M ,33D4K4KL MM%HHM zz]((333 <CC **m))+ ,, m%6%C%C D= c+m    * *mmM6>>Bm JJt.. / ??r-Nc`~~|j|}tj|d|dS)Nrr9)rrr)rnryr3r4tensorss r*rz._WeightedCategoricalColumn._get_sparse_tensors` s3 jjG  * *71:wqz BBr-r) rrrrrr'rrrzrrr-r*rUrU6 sU + ? ?   0 0@&.2$(Cr-rUrScReZdZdZedZedZdZedZ ddZ y) r]zSee `crossed_column`.cg}t|D]?}t|tr|j|j/|j|Adj t |S)N_X_)_collect_leaf_level_keysrXrr<r'joinr;)rn feature_namesr/s r*r'z_CrossedColumn.namep s[M'-" C (SXX&S! " ::f]+ ,,r-ci}|jD]b}t|tr|j|j/|j|t j tjid|Sr%) rZrXrrrrr;rr)rnrr/s r*rz"_CrossedColumn._parse_example_specz s_ FyyG C ( c--. sK55fmmDEF G Mr-cg}t|D]}t|tjr!|j |j |>t|t r]|j|}|j$tdj|j|j |jtdj|tj||j|j S)Nzmcrossed_column does not support weight_tensor, but the given column populates weight_tensor. Given column: {}z"Unsupported column type. Given: {})ryrLr[)rxrXrr\r<rrrrrZr[r'rrsparse_cross_hashedr.r[)rnryfeature_tensorsr/ids_and_weightss r*rzz!_CrossedColumn._transform_feature sO'- K C)) *vzz#/ c- .11&9  ( ( 4!!'!13 3 889=DDSIJJ K  ) )))  r-c|jSrFrGrus r*rz_CrossedColumn._num_buckets rHr-NcLtj|j|dSr%rJrs r*rz"_CrossedColumn._get_sparse_tensors rKr-rrLrr-r*r]r]j sT - -   ( ! ! .2$(Cr-r]rYcg}|jD]>}t|tr|jt |.|j |@|S)zCollects base keys by expanding all nested crosses. Args: cross: A `_CrossedColumn`. Returns: A list of strings or `_CategoricalColumn` instances. )rZrXr]extendrxr<)crossleaf_level_keysks r*rxrx sP/ :: a!^$5a89Q  r-cZeZdZdZedZdZedZedZd dZ d dZ y) rPzRepresents a one-hot column for use in deep networks. Args: categorical_column: A `_CategoricalColumn` which is created by `categorical_column_with_*` function. cLdj|jjS)Nz {}_indicator)r[rr'rus r*r'z_IndicatorColumn.name s  !8!8!=!= >>r-c"|jj|}|j}|j}|t j ||t |jd}t j|ddg|j}tj|j|j|jSt j|d}tj||jddd}t!j"|dg S) zReturns dense `Tensor` representing feature. Args: inputs: A `_LazyBuilder` object to access inputs. Returns: Transformed feature `Tensor`. Raises: ValueError: if input rank is not known at graph building time. r)sp_ids sp_valuesrRr)rrr)rrr)axis)rrrrr sparse_mergeintr? sparse_slicerr scatter_ndrrVsparse_tensor_to_denserr reduce_sum)rnryid_weight_pairrrweighted_columndense_id_tensorone_hot_id_tensors r*rzz#_IndicatorColumn._transform_feature s ,,@@HN((I"00M "//!--b124o #//!Q0?0K0KMo ! !/"9"9"1"8"8"1"="=??!77%O "))""2&    0t <z"_IndicatorColumn._get_dense_tensor si$ $))+EF  !'tyy$t7N7N2O'+'>'>!@ AA ::d r-c~~t|jtsCtdj |j t |j|j|j|}|jj|}tj|j}tj||S)NzIn indicator_column: {}. categorical_column must be of type _SequenceCategoricalColumn to use sequence_input_layer. Suggested fix: Use one of sequence_categorical_column_with_*. Given (type {}): {}r!)rXrrrZr[r'rrrrr#rrrr$s r*rz+_IndicatorColumn._get_sequence_dense_tensor s  d--/I J  !'tyy$t7N7N2O'+'>'>!@  AA::d#L,,@@HNAA  "O  8 8!? 9 DDr-r) rrrrrr'rzrr?r>rrr-r*rPrP s_ ? ?+=Z 7 7 O O H59+/Dr-rPrc d}tdt|D]}||jjdj*||}||jjd}K|j ||jjdrwt dj|j||j|||jjdy)a'Validates that the first dim (batch size) of all tensors are equal or None. Args: tensors: list of tensors to check. columns: list of feature columns matching tensors. Will be used for error messaging. Raises: ValueError: if one of the tensors has a variant batch size NrzcBatch size (first dimension) of each feature must be same. Batch size of columns ({}, {}): ({}, {})) r!rr6rfris_compatible_withrZr[r')rtcolumnsexpected_batch_sizer%bath_size_column_indexs r*rFrF6 s CL ! @aqzQ%%1  $!"%aj..33A6"55gaj6F6F6K6KA6NO 77=v./44gajoo#WQZ%5%5%:%:1%=8?@ @ @r-cReZdZdZedZedZdZedZ ddZ y) rz)Represents sequences of categorical data.c.|jjSr%)rr'rus r*r'z_SequenceCategoricalColumn.nameV s  " " ' ''r-c.|jjSr%rrus r*rz._SequenceCategoricalColumn._parse_example_specZ rr-c8|jj|Sr%)rrzrxs r*rzz-_SequenceCategoricalColumn._transform_feature^ s  " " 5 5f ==r-c.|jjSr%rorus r*rz'_SequenceCategoricalColumn._num_bucketsa rpr-Nc\|jj|}|j}|j}t j |}|d|dt j|ddg}tj||}|tj||}tj||S)Nrr9rX) rrrrr r6r reduce_prodrrrr) rnryr3r4rrrr6 target_shapes r*rz._SequenceCategoricalColumn._get_sparse_tensorse s,,@@HN((I"00M OOI &E!HeAh(<( 0 0 .2$(Er-r)NTNNNF)NTNNr)rNNNNTT)Nrrr%)qrrrr numpyrErtensorflow.python.eagerr tensorflow.python.feature_columnrrtensorflow.python.frameworkrrrrrtensorflow.python.layersr tensorflow.python.opsr r r r rrrrrrrrrrrrtensorflow.python.platformrrr;tensorflow.python.trainingrtensorflow.python.utilrrtensorflow.python.util.compatr tensorflow.python.util.tf_exportr tensorflow.tools.docsr!#_FEATURE_COLUMN_DEPRECATION_WARNING+_FEATURE_COLUMN_DEPRECATION_RUNTIME_WARNINGr_header deprecatedrTobjectrcrrLayerrrrrrrrrrgrr&rr/r?rIrNrQrVr^r add_metaclassABCMetarrYrrrrrr:rrrWrrr"rr'r)rr,r=rGrMrUr]rxrPrFrrr-r*rsT    +>.+J4)+1+&/*,*(-7,,*0+,<7.'96.'##,.2$('+ $15(-;|89 +,-IJ$(!'+ B5K.:B5R8.8.v89 ,-.IJ!&$(" EK/:EP4,0tzz0f4!^4::^B)X89 789IJ8K::8z &"&(,*.# $04\;@"& .."& H#VO=h06}}7@x>B=>;?39== tr48;==> q'h@EF.H(.~~HV{N~3&DJJ3&l3;;KVK K\& >& ^%) @26 >4+ + h8< =@  >  DG6DGP ,F^*Z4KCE4nC@ &8. ../B0?/NPC@L~D&K &'~DBLD&K  &'LD^  1C15{55#=#G I1Ch3CK=IJ3Cl3CK*OQ3Cl1C!3!7!7!7%A%L"N1Ch1CK$=?1Ch7CK+CE7Ct$}D|%9-{--.@/C.DF}D@@4)E!3!7!7!7%A&:%;"=)Er-