
    2Vhu                        d dl mZ d dl mZ d dl mZ d dlmZ d dlmZ d dlm	Z	 d dl
mZ d dl
mZ d d	lmZ d d
lmZ d dlmZ  G d d      Z G d d      Z ed       G d de             Z G d de	      Z G d de	      Zy)    )backend)layers)tree)keras_export)Layer)TFDataLayer)
saving_lib)serialization_lib)backend_utils)
tensorflow)	auto_namec                   :    e Zd ZddZed        Zd Zed        Zy)Crossc                 d    |dvrt        d|       t        |      | _        || _        || _        y )N>   intone_hotzdInvalid value for argument `output_mode`. Expected one of {'int', 'one_hot'}. Received: output_mode=)
ValueErrortuplefeature_namescrossing_dimoutput_mode)selfr   r   r   s       \/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/layers/preprocessing/feature_space.py__init__zCross.__init__   sF    00))47 
 #=1(&    c                 8    dj                  | j                        S )N_X_)joinr   r   s    r   namez
Cross.name   s    zz$,,--r   c                 J    | j                   | j                  | j                  dS )Nr   r   r   r"   r   s    r   
get_configzCross.get_config   s'    !// --++
 	
r   c                      | di |S N r&   clsconfigs     r   from_configzCross.from_config%       }V}r   Nr   )	__name__
__module____qualname__r   propertyr    r#   classmethodr*   r&   r   r   r   r      s4    	' . .
  r   r   c                   (    e Zd Zd Zd Zed        Zy)Featurec                     |dvrt        d|       || _        t        |t              rt	        j
                  |      }|| _        || _        y )N>   r   floatr   zmInvalid value for argument `output_mode`. Expected one of {'int', 'one_hot', 'float'}. Received: output_mode=)r   dtype
isinstancedictr
   deserialize_keras_objectpreprocessorr   )r   r6   r:   r   s       r   r   zFeature.__init__+   s_    99))47 
 
lD),EEL )&r   c                 p    | j                   t        j                  | j                        | j                  dS )Nr6   r:   r   )r6   r
   serialize_keras_objectr:   r   r   s    r   r#   zFeature.get_config:   s5    ZZ-DD!!  ++
 	
r   c                      | di |S r%   r&   r'   s     r   r*   zFeature.from_configC   r+   r   N)r-   r.   r/   r   r#   r1   r*   r&   r   r   r3   r3   *   s     '
  r   r3   zkeras.utils.FeatureSpacec                   |    e Zd ZdZed"d       Zed        Zed#d       Zed$d       Zed#d       Z	e	 d%d       Z
e	 	 	 	 d&d       Ze	 	 	 	 d&d	       Zed'd
       Zed'd       Z	 	 	 	 	 	 d( fd	Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zed        Zd Z d Z!d Z"d  Z#d! Z$ xZ%S ))FeatureSpacea  One-stop utility for preprocessing and encoding structured data.

    Arguments:
        feature_names: Dict mapping the names of your features to their
            type specification, e.g. `{"my_feature": "integer_categorical"}`
            or `{"my_feature": FeatureSpace.integer_categorical()}`.
            For a complete list of all supported types, see
            "Available feature types" paragraph below.
        output_mode: One of `"concat"` or `"dict"`. In concat mode, all
            features get concatenated together into a single vector.
            In dict mode, the FeatureSpace returns a dict of individually
            encoded features (with the same keys as the input dict keys).
        crosses: List of features to be crossed together, e.g.
            `crosses=[("feature_1", "feature_2")]`. The features will be
            "crossed" by hashing their combined value into
            a fixed-length vector.
        crossing_dim: Default vector size for hashing crossed features.
            Defaults to `32`.
        hashing_dim: Default vector size for hashing features of type
            `"integer_hashed"` and `"string_hashed"`. Defaults to `32`.
        num_discretization_bins: Default number of bins to be used for
            discretizing features of type `"float_discretized"`.
            Defaults to `32`.

    **Available feature types:**

    Note that all features can be referred to by their string name,
    e.g. `"integer_categorical"`. When using the string name, the default
    argument values are used.

    ```python
    # Plain float values.
    FeatureSpace.float(name=None)

    # Float values to be preprocessed via featurewise standardization
    # (i.e. via a `keras.layers.Normalization` layer).
    FeatureSpace.float_normalized(name=None)

    # Float values to be preprocessed via linear rescaling
    # (i.e. via a `keras.layers.Rescaling` layer).
    FeatureSpace.float_rescaled(scale=1., offset=0., name=None)

    # Float values to be discretized. By default, the discrete
    # representation will then be one-hot encoded.
    FeatureSpace.float_discretized(
        num_bins, bin_boundaries=None, output_mode="one_hot", name=None)

    # Integer values to be indexed. By default, the discrete
    # representation will then be one-hot encoded.
    FeatureSpace.integer_categorical(
        max_tokens=None, num_oov_indices=1, output_mode="one_hot", name=None)

    # String values to be indexed. By default, the discrete
    # representation will then be one-hot encoded.
    FeatureSpace.string_categorical(
        max_tokens=None, num_oov_indices=1, output_mode="one_hot", name=None)

    # Integer values to be hashed into a fixed number of bins.
    # By default, the discrete representation will then be one-hot encoded.
    FeatureSpace.integer_hashed(num_bins, output_mode="one_hot", name=None)

    # String values to be hashed into a fixed number of bins.
    # By default, the discrete representation will then be one-hot encoded.
    FeatureSpace.string_hashed(num_bins, output_mode="one_hot", name=None)
    ```

    Examples:

    **Basic usage with a dict of input data:**

    ```python
    raw_data = {
        "float_values": [0.0, 0.1, 0.2, 0.3],
        "string_values": ["zero", "one", "two", "three"],
        "int_values": [0, 1, 2, 3],
    }
    dataset = tf.data.Dataset.from_tensor_slices(raw_data)

    feature_space = FeatureSpace(
        features={
            "float_values": "float_normalized",
            "string_values": "string_categorical",
            "int_values": "integer_categorical",
        },
        crosses=[("string_values", "int_values")],
        output_mode="concat",
    )
    # Before you start using the FeatureSpace,
    # you must `adapt()` it on some data.
    feature_space.adapt(dataset)

    # You can call the FeatureSpace on a dict of data (batched or unbatched).
    output_vector = feature_space(raw_data)
    ```

    **Basic usage with `tf.data`:**

    ```python
    # Unlabeled data
    preprocessed_ds = unlabeled_dataset.map(feature_space)

    # Labeled data
    preprocessed_ds = labeled_dataset.map(lambda x, y: (feature_space(x), y))
    ```

    **Basic usage with the Keras Functional API:**

    ```python
    # Retrieve a dict Keras Input objects
    inputs = feature_space.get_inputs()
    # Retrieve the corresponding encoded Keras tensors
    encoded_features = feature_space.get_encoded_features()
    # Build a Functional model
    outputs = keras.layers.Dense(1, activation="sigmoid")(encoded_features)
    model = keras.Model(inputs, outputs)
    ```

    **Customizing each feature or feature cross:**

    ```python
    feature_space = FeatureSpace(
        features={
            "float_values": FeatureSpace.float_normalized(),
            "string_values": FeatureSpace.string_categorical(max_tokens=10),
            "int_values": FeatureSpace.integer_categorical(max_tokens=10),
        },
        crosses=[
            FeatureSpace.cross(("string_values", "int_values"), crossing_dim=32)
        ],
        output_mode="concat",
    )
    ```

    **Returning a dict of integer-encoded features:**

    ```python
    feature_space = FeatureSpace(
        features={
            "string_values": FeatureSpace.string_categorical(output_mode="int"),
            "int_values": FeatureSpace.integer_categorical(output_mode="int"),
        },
        crosses=[
            FeatureSpace.cross(
                feature_names=("string_values", "int_values"),
                crossing_dim=32,
                output_mode="int",
            )
        ],
        output_mode="dict",
    )
    ```

    **Specifying your own Keras preprocessing layer:**

    ```python
    # Let's say that one of the features is a short text paragraph that
    # we want to encode as a vector (one vector per paragraph) via TF-IDF.
    data = {
        "text": ["1st string", "2nd string", "3rd string"],
    }

    # There's a Keras layer for this: TextVectorization.
    custom_layer = layers.TextVectorization(output_mode="tf_idf")

    # We can use FeatureSpace.feature to create a custom feature
    # that will use our preprocessing layer.
    feature_space = FeatureSpace(
        features={
            "text": FeatureSpace.feature(
                preprocessor=custom_layer, dtype="string", output_mode="float"
            ),
        },
        output_mode="concat",
    )
    feature_space.adapt(tf.data.Dataset.from_tensor_slices(data))
    output_vector = feature_space(data)
    ```

    **Retrieving the underlying Keras preprocessing layers:**

    ```python
    # The preprocessing layer of each feature is available in `.preprocessors`.
    preprocessing_layer = feature_space.preprocessors["feature1"]

    # The crossing layer of each feature cross is available in `.crossers`.
    # It's an instance of keras.layers.HashedCrossing.
    crossing_layer = feature_space.crossers["feature1_X_feature2"]
    ```

    **Saving and reloading a FeatureSpace:**

    ```python
    feature_space.save("featurespace.keras")
    reloaded_feature_space = keras.models.load_model("featurespace.keras")
    ```
    c                     t        |||      S )N)r   )r   )r(   r   r   r   s       r   crosszFeatureSpace.cross  s    ]LkJJr   c                     t        |||      S N)r3   )r(   r6   r:   r   s       r   featurezFeatureSpace.feature  s    ulK88r   c                 \    |xs t        d      }t        d| d      }t        d|d      S )Nr5   float32_preprocessor)r6   r    r<   )r   TFDIdentityr3   r(   r    r:   s      r   r5   zFeatureSpace.float  s8    )y)"D69OP,G
 	
r   c                 r    |xs t        d      }t        j                  ||| d      }t        d|d      S )Nfloat_rescaledrH   )scaleoffsetr    rG   r5   r<   )r   r   	Rescalingr3   )r(   rM   rN   r    r:   s        r   rL   zFeatureSpace.float_rescaled  sF    2y!12''v]-C
 ,G
 	
r   c                 p    |xs t        d      }t        j                  d| d      }t        d|d      S )Nfloat_normalizedrH   )axisr    rG   r5   r<   )r   r   Normalizationr3   rJ   s      r   rQ   zFeatureSpace.float_normalized)  sD    4y!34++TF-0
 ,G
 	
r   c                 r    |xs t        d      }t        j                  ||| d      }t        d||      S )Nfloat_discretizedrH   )num_binsbin_boundariesr    rG   r<   )r   r   Discretizationr3   )r(   rW   rX   r   r    r:   s         r   rV   zFeatureSpace.float_discretized3  sJ     5y!45,,)6'

 ,K
 	
r   c                 r    |xs t        d      }t        j                  | d||      }t        d||      S )Ninteger_categoricalrH   r    
max_tokensnum_oov_indicesint32r<   )r   r   IntegerLookupr3   r(   r]   r^   r   r    r:   s         r   r[   z FeatureSpace.integer_categoricalA  sJ     7y!67++6'!+

 +
 	
r   c                 r    |xs t        d      }t        j                  | d||      }t        d||      S )Nstring_categoricalrH   r\   stringr<   )r   r   StringLookupr3   ra   s         r   rc   zFeatureSpace.string_categoricalS  sJ     6y!56**6'!+

 ;
 	
r   c                 p    |xs t        d      }t        j                  | d|      }t        d||      S )Nstring_hashedrH   r    rW   rd   r<   r   r   Hashingr3   r(   rW   r   r    r:   s        r   rg   zFeatureSpace.string_hashede  sA    1y1~~6'(
 ;
 	
r   c                 p    |xs t        d      }t        j                  | d|      }t        d||      S )Ninteger_hashedrH   rh   r_   r<   ri   rk   s        r   rm   zFeatureSpace.integer_hashedo  sB    2y!12~~6'(
 +
 	
r   c           	         t         |   |       |st        d      || _        || _        || _        |j                         D ci c]  \  }}|| j                  ||       c}}| _        g | _	        |rt        |j                               }	|D ]  }
t        |
t              rt        j                  |
      }
t        |
t               r| j                  j#                  |
       T|st        d      |
D ]  }||	vst        d|
        | j                  j#                  t!        |
|              | j                  D 
ci c]  }
|
j$                  |
 c}
| _        |dvrt        d|       || _        | j                  j                         D ci c]  \  }}|| j+                  ||       c}}| _        | j                  j                         D ci c]  \  }}||j.                   c}}| _        d | _        | j                  D 
ci c]  }
|
j$                  | j5                  |
        c}
| _        i | _        d| _        d | _        d | _        d | _         d| _!        y c c}}w c c}
w c c}}w c c}}w c c}
w )	Nr    z0The `features` argument cannot be None or empty.zzWhen specifying `crosses`, the argument `crossing_dim` (dimensionality of the crossing space) should be specified as well.zwAll features referenced in the `crosses` argument should be present in the `features` dict. Received unknown features: )r   >   r8   concatzdInvalid value for argument `output_mode`. Expected one of {'dict', 'concat'}. Received: output_mode=F)"superr   r   r   hashing_dimnum_discretization_binsitems_standardize_featurefeaturescrossessetkeysr7   r8   r
   r9   r   appendr    crosses_by_namer   _feature_to_inputinputsr:   preprocessorsencoded_features_cross_to_crossercrossersone_hot_encoders_is_adaptedrp   _preprocessed_features_names_crossed_features_names_sublayers_built)r   rv   r   rw   r   rr   rs   r    valuefeature_setrB   key	__class__s               r   r   zFeatureSpace.__init__y  s    	d#OPP(&'>$  (~~/
e $++D%88
 hmmo.K  QeT*-FFuMEeU+LL''.'(;   % k1",!> ?DW!F#  LL''e,(OP+Q, @D||Le

E 1L00))47 
 '  $}}224
e $((u55

 9=8K8K8M
)4uD%$$$
 !%CG<<
:?EJJ..u55
 !# ,0)'+$ %o
:  M


s   I!I'I,I2#I8c                 F    t        j                  d|j                  |      S )N)   )shaper6   r    )r   Inputr6   r   r    rE   s      r   r|   zFeatureSpace._feature_to_input  s    ||$gmm$GGr   c                 >   t        |t              r|S t        |t              rt        j                  |      S |dk(  r| j                  |      S |dk(  r| j                  |      S |dk(  r| j                  |      S |dk(  r| j                  || j                        S |dk(  r| j                  |      S |dk(  r| j                  |      S |d	k(  r| j                  | j                  |      S |d
k(  r| j                  | j                  |      S t        d|       )Nr5   ro   rQ   rL   rV   rh   r[   rc   rm   rg   zInvalid feature type: )r7   r3   r8   r
   r9   r5   rQ   rL   rV   rs   r[   rc   rm   rr   rg   r   r   s      r   ru   z!FeatureSpace._standardize_feature  sC   gw'Ngt$$==gFFg::4:((**((d(33((&&D&11++))D$@$@ *   --+++66,,***55((&&t'7'7d&CC'%%d&6&6T%BB5gY?@@r   c                 X    t        j                  |j                  |j                        S )Nro   )r   HashedCrossingr   r    )r   rB   s     r   r   zFeatureSpace._cross_to_crosser  s    $$U%7%7ejjIIr   c                 >   g }| j                   j                         D ]}  }| j                  |   }t        |t        j
                        r|j                  (9t        |t        j                        r|j                  r`t        |d      sm|j                  |        |S )Nadapt)rv   ry   r~   r7   r   rT   
input_meanTextVectorization_has_input_vocabularyhasattrrz   )r   adaptable_preprocessorsr    r:   s       r   _list_adaptable_preprocessorsz*FeatureSpace._list_adaptable_preprocessors  s    "$MM&&( 	5D--d3L ,(<(<=**6L&*B*BC55|W-'..t4	5 '&r   c                 ,   t        |t        j                  j                        st	        d| dt        |       d      | j                         D ]  |j                  fd      }| j                     }t        t        |            }t        |j                        dk(  r|j                  d      }t        |j                        dv r|j                  d       }|j                  |        d	| _        | j!                          d	| _        d	| _        y )
NzE`adapt()` can only be called on a tf.data.Dataset. Received instead: 
 (of type )c                     |    S rD   r&   )xr    s    r   <lambda>z$FeatureSpace.adapt.<locals>.<lambda>  s    AdG r   r       >   r   r   c                 .    t        j                  | d      S )NrR   )tfexpand_dimsr   s    r   r   z$FeatureSpace.adapt.<locals>.<lambda>  s    bnnQ3 r   T)r7   r   dataDatasetr   typer   mapr~   nextiterlenr   batchr   r   get_encoded_featuresbuiltr   )r   datasetfeature_datasetr:   r   r    s        @r   r   zFeatureSpace.adapt  s   '277??3%%,IZWaI 
 668 	0D &kk*;<O--d3L T/*+A177|q "1"7"7";177|v% #2"5"53# //	00  !!#
 $r   c                 :    | j                          | j                  S rD   )_check_if_builtr}   r   s    r   
get_inputszFeatureSpace.get_inputs  s    {{r   c                     | j                          | j                  E| j                  | j                        }| j	                  |      }| j                  ||      }|| _        | j                  S rD   )_check_if_adaptedr   _preprocess_featuresr}   _cross_features_merge_features)r   preprocessed_featurescrossed_featuresmerged_featuress       r   r   z!FeatureSpace.get_encoded_features  sm       ($($=$=dkk$J!#334IJ"22%'7O %4D!$$$r   c                 v    |j                         D ci c]  }| | j                  |   ||          c}S c c}w rD   )ry   r~   )r   rv   r    s      r   r   z!FeatureSpace._preprocess_features)  sF     !
 *$$$T*8D>::
 	
 
s    6c                     i }| j                   D ]L  }|j                  D cg c]  }||   	 }} | j                  |j                     |      }|||j                  <   N |S c c}w rD   )rw   r   r   r    )r   rv   all_outputsrB   r    r}   outputss          r   r   zFeatureSpace._cross_features/  sl    \\ 	.E161D1DEhtnEFE/dmmEJJ/7G&-K

#	.  Fs   A c                    | j                   s<t        |j                               | _         t        |j                               | _        | j                   | j                  z   }| j                   D cg c]  }||   	 c}| j                  D cg c]  }||   	 c}z   }| j                  dk(  ri }ng }| j
                  rt        ||      D ]Q  \  }}| j                  j                  |d       }	|	r |	|      }| j                  dk(  r||<   Aj                  |       S | j                  dk(  rS | j                        S | j                   D cg c]  }| j                  |    c}| j                  D cg c]  }| j                  |    c}z   }
t        |||
      D ]'  \  }}}t        j                  |      r#t        j                  |      d   j                   }n|j                   }t#        j$                  |      }|j                  dk(  r\| j&                  j                  |      xs | j(                  j                  |      }d }|j+                  d      st-        d| d| d      t/        |t0        j2                  t0        j4                  f      r|j7                         }nt/        |t0        j8                        r|j:                  }nmt/        |t0        j<                        r|j>                  }nFt/        |t0        j@                  t0        jB                  f      r|j>                  }nt-        d| d      |.t1        j8                  |d	
      }	|	| j                  |<    |	|      }| j                  dk(  rG|j                   }|j+                  d      s|dk(  rt-        d| d| d      j                  |       #||<   * | j                  dk(  r"tE        d      | _
        | j                        S S c c}w c c}w c c}w c c}w )Nr8   r   r   r   z	Feature 'zj' has `output_mode='one_hot'`. Thus its preprocessor should return an integer dtype. Instead it returns a z dtype.z' has `output_mode='one_hot'`. However it isn't a standard feature and the dimensionality of its output space is not known, thus it cannot be one-hot encoded. Try using `output_mode='int'`.	multi_hot)
num_tokensr   rp   rd   z-Cannot concatenate features because feature 'z%' has not been encoded (it has dtype z'). Consider using `output_mode='dict'`.rR   rS   )#r   sortedry   r   r   r   zipr   getrz   rp   rv   r{   r   	is_nestedflattenr6   r   standardize_dtyper~   r   
startswithr   r7   r   r`   re   vocabulary_sizeCategoryEncodingr   rY   rW   r   rj   	TFDConcat)r   r   r   	all_namesr    all_featuresoutput_dictfeatures_to_concatrE   encoder	all_specsspecr6   r:   cardinalitys                  r   r   zFeatureSpace._merge_features7  s   0006%**,1D- ,22B2G2G2I+JD( --0L0LL 	
 99
 "$'
 150L0LMd#MN
 v%K!#  !$Y!= 7g//33D$?%g.G##v-(/K%&--g67 6)""{{#566
 -1,M,M
$(DMM$
 483O3O
+/D  &

	 $'y,	#J 9	,D'4~~g&W-a066--e4E9,#1155   -]]&&t,  #''.$#D6 *005wg?   6#7#79L9L"M #/">">"@Kf.E.EF"."9"9Kf.C.CD"."7"7K 6#8#8&.."I #/"7"7K$#D6 *9 9  *$55#.KG 3:D))$/%g.G8+##E*ex.?$Gv N>>CW E?? 
 #))'2$+D!s9	,v x'#,DK;;122A
 N0

s   0O9O>P3Pc                 b    | j                   s#| j                         sd| _         y t        d      y )NTzUYou need to call `.adapt(dataset)` on the FeatureSpace before you can start using it.)r   r   r   r   s    r   r   zFeatureSpace._check_if_adapted  s6    557#'  5 	  r   c                 l    | j                   s(| j                          | j                          d| _         y y NT)r   r   r   r   s    r   r   zFeatureSpace._check_if_built  s0    $$""$%%'$(D!	 %r   c                    t        |t        j                  t        j                  t        j                  f      sJt        |t
        t        t        t        f      st        j                  |      }t        j                  |      }|S rD   )r7   r   TensorSparseTensorRaggedTensorlistr   r   r5   r   convert_to_numpyconvert_to_tensorr   r   s     r   _convert_inputzFeatureSpace._convert_input  sW    !bii"//JKa$sE!:;,,Q/$$Q'Ar   c                 F     j                          t        |t              st        d| dt	        |             |j                         D ci c]  \  }}| j                  |       }}}d}|j                         D ]k  \  }}t        |j                        dk(  rt        j                  |d      ||<   d}:t        |j                        dk(  sSt        j                  |d      ||<   m t        j                         5   j                  |      }t        j                    fd	|      } j#                  |      }t        j                    fd
|      } j%                  ||      }	d d d        |rى j&                  dk(  rl	j                  d   dk(  sJ t)        j(                         dk7  r)t        j*                         st)        j,                  |	      }	t        j.                  |	d      }	n^	j                         D ]K  \  }}t        |j                        dk(  s|j                  d   dk(  s2t        j.                  |d      |	|<   M t)        j(                         dk7  r+t        j*                         st        j                   d 	      }		S c c}}w # 1 sw Y   /xY w)Nz>A FeatureSpace can only be called with a dict. Received: data=r   Fr   )r   r   Tr   rR   c                 &    j                  |       S rD   r   r   r   s    r   r   z'FeatureSpace.__call__.<locals>.<lambda>      $--a0 r   c                 &    j                  |       S rD   r   r   s    r   r   z'FeatureSpace.__call__.<locals>.<lambda>  r   r   rp   r   r      c                 D    t        j                  | | j                        S )N)r6   )r   r   r6   r   s    r   r   z'FeatureSpace.__call__.<locals>.<lambda>  s    '33AQWWE r   )r   r7   r8   r   r   rt   r   r   r   r   reshaper   r   TFGraphScoper   r   map_structurer   r   r   r   in_tf_graphr   squeeze)
r   r   r   r   	rebatchedr    r   preprocessed_datacrossed_datamerged_datas
   `         r   __call__zFeatureSpace.__call__  sc   $%""&z$t*?  CG**,OJCT((//OO	zz| 	3GD!177|q ZZ62T
 	QWW"^^Ar2T
	3 '') 	P !% 9 9$ ? $ 2 202C!  //0ABL--0,L ../@,OK	P  8+"((+q000OO%5)557")":":;"GK jj1=*002 BGD!177|q(QWWQZ1_,.JJqq,AD)B
 OO-!--/,,EK _ P	P 	Ps   JA'JJ c                     t        j                  | j                        | j                  t        j                  | j                        | j
                  | j                  | j                  dS )N)rv   r   rw   r   rr   rs   )r
   r=   rv   r   rw   r   rr   rs   r   s    r   r#   zFeatureSpace.get_config  sT    )@@O++(??M --++'+'C'C
 	
r   c                      | di |S r%   r&   r'   s     r   r*   zFeatureSpace.from_config   r+   r   c                     | j                   j                         D ci c]   \  }}||j                  j                         " c}}S c c}}w rD   )rv   rt   r:   get_build_configr   s      r   r   zFeatureSpace.get_build_config  sI     "&!4!4!6
g '&&7799
 	
 
s   %Ac                     |j                         D ]<  }| j                  |   j                  }|j                  r)|j	                  ||          > d| _        y r   )ry   rv   r:   r   build_from_configr   )r   r)   r    r:   s       r   r   zFeatureSpace.build_from_config
  sP    KKM 	=D==.;;L%%..vd|<	=  r   c                 0    t        j                  | |       y)a  Save the `FeatureSpace` instance to a `.keras` file.

        You can reload it via `keras.models.load_model()`:

        ```python
        feature_space.save("featurespace.keras")
        reloaded_fs = keras.models.load_model("featurespace.keras")
        ```
        N)r	   
save_model)r   filepaths     r   savezFeatureSpace.save  s     	dH-r   c                      y rD   r&   r   stores     r   save_own_variableszFeatureSpace.save_own_variables      r   c                      y rD   r&   r   s     r   load_own_variableszFeatureSpace.load_own_variables   r  r   r,   rD   )g      ?g        N)Nr   N)Nr   r   N)r   N)rp   Nr   r   r   N)&r-   r.   r/   __doc__r1   rB   rE   r5   rL   rQ   rV   r[   rc   rg   rm   r   r|   ru   r   r   r   r   r   r   r   r   r   r   r   r   r#   r*   r   r   r   r  r  __classcell__r   s   @r   r@   r@   H   s   CJ K K 9 9 
 
 
 
 
 
 HL
 
  
 
"  
 
" 
 
 
 
  "G&RHA8J'""%H
%
jX)9v
  
 
.r   r@   c                   $     e Zd Z fdZd Z xZS )r   c                 2    t        |   di | || _        y r%   )rq   r   rS   )r   rS   kwargsr   s      r   r   zTFDConcat.__init__%  s    "6"	r   c                 d    | j                   j                  j                  || j                        S )Nr   )r   numpyconcatenaterS   )r   xss     r   callzTFDConcat.call)  s&    ||!!--btyy-AAr   )r-   r.   r/   r   r  r  r  s   @r   r   r   $  s    Br   r   c                       e Zd Zd Zy)rI   c                     |S rD   r&   r   s     r   r  zTFDIdentity.call.  s    r   N)r-   r.   r/   r  r&   r   r   rI   rI   -  s    r   rI   N)	keras.srcr   r   r   keras.src.api_exportr   keras.src.layers.layerr   ,keras.src.layers.preprocessing.tf_data_layerr   keras.src.savingr	   r
   keras.src.utilsr   keras.src.utils.module_utilsr   r   keras.src.utils.namingr   r   r3   r@   r   rI   r&   r   r   <module>r     sy       - ( D ' . ) 9 , 8 < ()X5 X *XvB B+ r   