6biHSrSSKJr SSKJr SSKJr SSKrSSKJs Jr SSK J r SSK J r SSKJr SS KJr \"S /S 9"S S \R&55rg)zHA layer that produces a dense `Tensor` based on given `feature_columns`.)absolute_import)division)print_functionN)backend)base_feature_layer) json_utils) keras_exportzkeras.layers.DenseFeatures)v1cl^\rSrSrSrS U4Sjjr\S5r\U4Sj5rSr S Sjr Sr U=r $) DenseFeatures!aA layer that produces a dense `Tensor` 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`. This layer can be called multiple times with different features. This is the V1 version of this layer that uses variable_scope's or partitioner to create variables which works well with PartitionedVariables. Variable scopes are deprecated in V2, so the V2 version uses name_scopes instead. But currently that lacks support for partitioned variables. Use this if you need partitioned variables. Use the partitioner argument if you have a TF-Keras model and uses `tf.compat.v1.keras.estimator.model_to_estimator` for training. Example: ```python price = tf.feature_column.numeric_column('price') keywords_embedded = tf.feature_column.embedding_column( tf.feature_column.categorical_column_with_hash_bucket("keywords", 10K), dimension=16) columns = [price, keywords_embedded, ...] partitioner = tf.compat.v1.fixed_size_partitioner(num_shards=4) feature_layer = tf.compat.v1.keras.layers.DenseFeatures( feature_columns=columns, partitioner=partitioner) features = tf.io.parse_example( ..., features=tf.feature_column.make_parse_example_spec(columns)) dense_tensor = feature_layer(features) for units in [128, 64, 32]: dense_tensor = tf.compat.v1.keras.layers.Dense( units, activation='relu')(dense_tensor) prediction = tf.compat.v1.keras.layers.Dense(1)(dense_tensor) ``` c v>[TU]"SUUUU[RRR S.UD6 g)aConstructs a DenseFeatures layer. Args: 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`. trainable: Boolean, whether the layer's variables will be updated via gradient descent during training. name: Name to give to the DenseFeatures. partitioner: Partitioner for input layer. Defaults to `None`. **kwargs: Keyword arguments to construct a layer. Raises: ValueError: if an item in `feature_columns` is not a `DenseColumn`. )feature_columns trainablename partitionerexpected_column_typeN)super__init__tf __internal__feature_column DenseColumn)selfrrrrkwargs __class__s d/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/feature_column/dense_features.pyrDenseFeatures.__init__Is@4  +#!#!?!?!K!K    cg)NTr)rs r_is_feature_layerDenseFeatures._is_feature_layerlsr c>[R"[TU] 5nSUS'[R"U[ R S9$)zString stored in metadata field in the SavedModel proto. Returns: A serialized JSON storing information necessary for recreating this layer. Tr")default)jsonloadsr_tracking_metadatadumpsr get_json_type)rmetadatars rr( DenseFeatures._tracking_metadataps:::eg89(,$%zz(J,D,DEEr cUSU4$)Nrr)r input_shapetotal_elementss r _target_shapeDenseFeatures._target_shape|sA//r chUc[R"5n[U[5(d [ SU5e[ R RRU5n/nURHqn[R"UR5 URUURUS9nURXg5nUbXU'UR!U5 SSS5 Ms UR#U5$![a URX@R5nNmf=f!,(df  M=f)a>Returns a dense tensor corresponding to the `feature_columns`. Example usage: >>> t1 = tf.feature_column.embedding_column( ... tf.feature_column.categorical_column_with_hash_bucket("t1", 2), ... dimension=8) >>> t2 = tf.feature_column.numeric_column('t2') >>> feature_layer = tf.compat.v1.keras.layers.DenseFeatures([t1, t2]) >>> features = {"t1": tf.constant(["a", "b"]), ... "t2": tf.constant([1, 2])} >>> dense_tensor = feature_layer(features, training=True) 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`. cols_to_output_tensors: If not `None`, this will be filled with a dict mapping feature columns to output tensors created. training: Python boolean or None, indicating whether to the layer is being run in training mode. This argument is passed to the call method of any `FeatureColumn` that takes a `training` argument. For example, if a `FeatureColumn` performed dropout, the column could expose a `training` argument to control whether the dropout should be applied. If `None`, becomes `tf.keras.backend.learning_phase()`. Defaults to `None`. Returns: A `Tensor` which represents input layer of a model. Its shape is (batch_size, first_layer_dimension) and its dtype is `float32`. first_layer_dimension is determined based on given `feature_columns`. Raises: ValueError: If features are not a dictionary. Nz/We expected a dictionary here. Instead we got: )training)rlearning_phase isinstancedict ValueErrorrrrFeatureTransformationCache_feature_columns name_scoperget_dense_tensor_state_manager TypeError_process_dense_tensorappend_verify_and_concat_tensors) rfeaturescols_to_output_tensorsr3transformation_cacheoutput_tensorscolumntensorprocessed_tensorss rcallDenseFeatures.calls'L  --/H(D))A8  OO * * E Eh O ++F##FKK0 #44,++!)5F%)$>$>v$N!)55F62%%&7810, ..~>>!#44,.A.AF10s0D"C71)D"7%DD"DD"" D1 r)TNN)NN) __name__ __module__ __qualname____firstlineno____doc__rpropertyr"r(r0rH__static_attributes__ __classcell__)rs@rr r !sU$R  ! F F F0@?@?r r )rN __future__rrrr&tensorflow.compat.v2compatv2r tf_keras.srcrtf_keras.src.feature_columnrkfc&tf_keras.src.saving.legacy.saved_modelr tensorflow.python.util.tf_exportr _BaseFeaturesLayerr rr rr\sXO&% !! A=:./0]?C**]?1]?r