BVh~\0dZddlZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd l mZdd lmZdd lmZdd lmZdd lmZddlmZddlmZe j:Zdaej>dZ dZ!dZ"Gdde jFZ#dZ$y)z=Contains the base Layer class, from which all layers inherit.N)context)dtypes)ops)backend) base_layer)base_layer_utils)variable_scope_shim)policy) tf_contextlib)variable_scope) variables)base)nestFc#8Kt}da d|ay#|awxYww)aUse Keras-style variable management. All tf.layers and tf RNN cells created in this scope use Keras-style variable management. Creating such layers with a scope= argument is disallowed, and reuse=True is disallowed. The purpose of this scope is to allow users of existing layers to slowly transition to a Keras layers API without breaking existing functionality. One example of this is when using TensorFlow's RNN classes with Keras Models or Networks. Because Keras models do not properly set variable scopes, users of RNNs may either accidentally share scopes between two different models, or get errors about variables that already exist. Example: ```python class RNNModel(tf.keras.Model): def __init__(self, name): super(RNNModel, self).__init__(name=name) self.rnn = tf.compat.v1.nn.rnn_cell.MultiRNNCell( [tf.compat.v1.nn.rnn_cell.LSTMCell(64) for _ in range(2)]) def call(self, input, state): return self.rnn(input, state) model_1 = RNNModel("model_1") model_2 = RNNModel("model_2") # OK output_1, next_state_1 = model_1(input, state) # Raises an error about trying to create an already existing variable. output_2, next_state_2 = model_2(input, state) ``` The solution is to wrap the model construction and execution in a keras-style scope: ```python with keras_style_scope(): model_1 = RNNModel("model_1") model_2 = RNNModel("model_2") # model_1 and model_2 are guaranteed to create their own variables. output_1, next_state_1 = model_1(input, state) output_2, next_state_2 = model_2(input, state) assert len(model_1.weights) > 0 assert len(model_2.weights) > 0 assert(model_1.weights != model_2.weights) ``` Yields: A keras layer style scope. TN_KERAS_STYLE_SCOPE)stacks ]/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/keras/legacy_tf_layers/base.pykeras_style_scoper)s(x % s cday)aUse Keras-style variable management. All tf.layers and tf RNN cells created after keras style ha been enabled use Keras-style variable management. Creating such layers with a scope= argument is disallowed, and reuse=True is disallowed. The purpose of this function is to allow users of existing layers to slowly transition to Keras layers API without breaking existing functionality. For more details, see the documentation for `keras_style_scope`. Note, once keras style has been set, it is set globally for the entire program and cannot be unset. Example: ```python set_keras_style() model_1 = RNNModel(name="model_1") model_2 = RNNModel(name="model_2") # model_1 and model_2 are guaranteed to create their own variables. output_1, next_state_1 = model_1(input, state) output_2, next_state_2 = model_2(input, state) assert len(model_1.weights) > 0 assert len(model_2.weights) > 0 assert(model_1.weights != model_2.weights) ``` TNrrset_keras_stylerms DrctSNrrrr_is_in_keras_style_scopers rc eZdZdZdfd ZedZdZ ddZedZ dfd Z fd Z dd Z dddddde jje j j"df fd Zfd Zd ZfdZedZxZS)Layera"Base layer class. It is considered legacy, and we recommend the use of `tf.keras.layers.Layer` instead. Args: trainable: Boolean, whether the layer's variables should be trainable. name: String name of the layer. dtype: Default dtype of the layer's weights (default of `None` means use the type of the first input). Read-only properties: name: The name of the layer (string). dtype: Default dtype of the layer's weights (default of `None` means use the type of the first input). trainable_variables: List of trainable variables. non_trainable_variables: List of non-trainable variables. variables: List of all variables of this layer, trainable and non-trainable. updates: List of update ops of this layer. losses: List of losses added by this layer. trainable_weights: List of variables to be included in backprop. non_trainable_weights: List of variables that should not be included in backprop. weights: The concatenation of the lists trainable_weights and non_trainable_weights (in this order). Mutable properties: trainable: Whether the layer should be trained (boolean). input_spec: Optional (list of) `InputSpec` object(s) specifying the constraints on inputs that can be accepted by the layer. Nc d|_|jdd}|jdd|_g|_d|_|t j d}d|vrd|d<d|_tt|*d |||d|trT|tdj||j$td j|jd|_nd|_d |jv|_|r-t#j$|5}||_dddd|_yd|_d|_y#1swYd|_yxYw) NF_scope_reuse_inferautocastT) trainablenamedtypeKscope argument not allowed when keras style layers are enabled, but saw: {}zKreuse argument not allowed when keras style layers are enabled, but saw: {}scoper)_use_resource_variablespopr!_trainable_weightsbuiltr Policy_disable_keras_instrumentationsuperr__init__r ValueErrorformat _keras_style _call_fn_args_call_has_scope_argvsr r _current_scope)selfr$r%r&kwargsr(captured_scope __class__s rr0zLayer.__init__s\$)D JJx &E**Xt,DK!DDJ }mmH%e fZ+/D' %*)$e*"(* !    &-) )    &-/ /dd&$*<*<|d 5}||_ tCjD|jG5|xs|jHxs |jJ}| |jL}tt|||ft/jN|||xr |j || || | t jPd | }|rbtjRs ||rE|jU|||t jV}tY|d r|j[|||w|j]5t)j^}ddd|rH|j r<|vr8|j:|d}|j:d||_|xj`|z c_0ddddddS#1swY!xYw#1swYrxYw#1swY,xYw#1swYSxYw) a Adds a new variable to the layer, or gets an existing one; returns it. Args: name: variable name. shape: variable shape. dtype: The type of the variable. Defaults to `self.dtype` or `float32`. initializer: initializer instance (callable). regularizer: regularizer instance (callable). trainable: whether the variable should be part of the layer's "trainable_variables" (e.g. variables, biases) or "non_trainable_variables" (e.g. BatchNorm mean, stddev). Note, if the current variable scope is marked as non-trainable then this parameter is ignored and any added variables are also marked as non-trainable. `trainable` defaults to `True` unless `synchronization` is set to `ON_READ`. constraint: constraint instance (callable). use_resource: Whether to use `ResourceVariable`. synchronization: Indicates when a distributed a variable will be aggregated. Accepted values are constants defined in the class `tf.VariableSynchronization`. By default the synchronization is set to `AUTO` and the current `DistributionStrategy` chooses when to synchronize. If `synchronization` is set to `ON_READ`, `trainable` must not be set to `True`. aggregation: Indicates how a distributed variable will be aggregated. Accepted values are constants defined in the class `tf.VariableAggregation`. partitioner: (optional) partitioner instance (callable). If provided, when the requested variable is created it will be split into multiple partitions according to `partitioner`. In this case, an instance of `PartitionedVariable` is returned. Available partitioners include `tf.compat.v1.fixed_size_partitioner` and `tf.compat.v1.variable_axis_size_partitioner`. For more details, see the documentation of `tf.compat.v1.get_variable` and the "Variable Partitioners and Sharding" section of the API guide. **kwargs: Additional keyword arguments. Returns: The created variable. Usually either a `Variable` or `ResourceVariable` instance. If `partitioner` is not `None`, a `PartitionedVariable` instance is returned. Raises: RuntimeError: If called with partitioned variable regularization and eager execution is enabled. ValueError: When trainable has been set to True with synchronization set as `ON_READ`. experimental_autocastzUnknown keyword argument:) r%shaper& initializerrer$ constraint use_resourcesynchronization aggregation partitionerzSynchronization value can be set to VariableSynchronization.ON_READ only for non-trainable variables. You have specified trainable=True and synchronization=VariableSynchronization.ON_READ.FNTcPtj|r|D]}||vsyy||vS)NFT)ris_split_variable)variableexisting_variable_setvars r_should_add_regularizerz1Layer.add_weight.._should_add_regularizers<  + +H 5 C ) ) 444rreuseauxiliary_name_scope) r&rpr$rqrurrrsrtgetteradd_regularizerr)1 TypeErrorr3r/r add_weightr$r6VariableSynchronizationAUTOVariableAggregationNONEON_READr1rr?rget_default_graphbuilding_function init_scopeset tf_variablesglobal_variablesr&rfloat32rlr,r!rXr+r r r7r name_scoperhr)rrrpas_dtype get_variable#executing_eagerly_outside_functions_handle_weight_regularization_get_default_variable_storehasattrr as_defaulttrainable_variables_non_trainable_weights)r8r%ror&rprer$rqrrrsrtrur9kwargr{ init_graph default_graphexisting_variablesr}prev_len_trainabler(rx var_storerextra_trainable_varsr;s rrzLayer.add_weight9sx< ) )3U;;<  5$ * !!0$..#4499,,11!    "44<<<  ?@ @  i5J  $ $ &++-m  ( ( ^^  F **,..0J!$\%B%B%D!E  F F#  !>!>!@A }jj*FNNeOOD JJ %$++ET445   5u >/@AF!d   d..0 1,@$+44+**   ))+0   //%(#2DNN!#%+#??   557(3EF  . .tX{ K668Iy"34''+>  ! $$& E"."B"B"D  EDNN11#'#:#:;M;N#O &*&=&=##'%D #  ' '+? ? 'Y,@/@` OG F Ft E EI,@,@/@` OsKAN1+N+C1N N"AN4N+NN NN( $N++N5c|jdd}|jr3|tdj|t t ||g|i|S|j||jrM |j}|jtj|jdd}tjs4||_ n,tj|j|j d}|5}||_ |j$}|r||d<t t ||g|i|}dddt/j0s.t3|j4tj6j8S#t$rd}YwxYw#t$rFt'j(|j*|_d|j,v|_|j$}YwxYw#1swYxYw)aWraps `call`, applying pre- and post-processing steps. Args: inputs: input tensor(s). *args: additional positional arguments to be passed to `self.call`. **kwargs: additional keyword arguments to be passed to `self.call`. **Note**: kwarg `scope` is reserved for use by the layer. Returns: Output tensor(s). Note: - If the layer's `call` method takes a `scope` keyword argument, this argument will be automatically set to the current variable scope. - If the layer's `call` method takes a `mask` argument (as some Keras layers do), its default value will be set to the mask generated for `inputs` by the previous layer (if `input` did come from a layer that generated a corresponding mask, i.e. if it came from a Keras layer with masking support. Raises: ValueError: if the layer's `call` method returns None (an invalid value). r(Nr'TFr|)r*r3r1r2r/r__call__rlr,_always_reuse_variable_scopeAttributeErrorr6r r rrr!r7r5r fn_argscallr4rr?r]updatesr^ UPDATE_OPS) r8rWargsr9r(scope_context_managercall_has_scope_argoutputsr;s rrzLayer.__call__s0 JJw %E     &-) )5$ ( A$ A& AAOOE zz%!% A A  &!# 1 1 KKt%!A 668.C$ + // ++T[[uF  E%!d6!55 weT+FDTDVDg E  $ $ &!$,, 0H0HI NK% $%06088C#*d.@.@#@ !556 E EsC1 E*+G 4 E;G * E87E8;A G G  G  G  Gc tgd}tddg}|j}|j|}||t|<|jj D]\}}||vrt |||||vr!t ||tj|=tj|rt |||`t ||tj|||S)N)_graph _thread_local _metrics_lockr r) rr;__new__id__dict__itemssetattrcopyris_tensor_or_tensor_listdeepcopy)r8memono_copy shallow_copyclsresultkvs r __deepcopy__zLayer.__deepcopy__5s>?G"@ABL ..C [[ FDDN ##%31 g1 499Q<(  . .q 114==D123 MrcBttj|||yr)r/ trackable Trackable __setattr__)r8valuer%r;s rrzLayer.__setattr__Fs )  t0=rcy)zDUsed by keras to check compatibility. This should not be overridden.TrrAs r_is_legacy_layerzLayer._is_legacy_layerJs r)TNN)NNFr)rR __module__ __qualname____doc__r0propertyrBrKrFrUr[rhrlr6rrrrrrrrr __classcell__)r;s@rrrsB.d    >B16   /"3 '!! "!#!;!;!@!@3388!kZM^">  rrc`tjrtd|d|tj|}tj|}|D]U}t j |}|Dchc] }t|}}|D]!}t||vs|j|#Wycc}w)NzHUsing collections from Layers not supported in Eager mode. Tried to add z to ) rr?r@rflattenrget_collection_refrr\)elementscollection_listr% collectionecollection_setelements rr]r]Ps  8@8GI JJ\\( #(LL1/#d''-J%/0be0N0# GN *'"##0s.B+)%rrr=tensorflow.python.eagerrtensorflow.python.frameworkrrtensorflow.python.kerasrtensorflow.python.keras.enginerr(tensorflow.python.keras.legacy_tf_layersr 'tensorflow.python.keras.mixed_precisionr tensorflow.python.keras.utilsr tensorflow.python.opsr r6r rtensorflow.python.trackablerrtensorflow.python.utilr InputSpecrcontextmanagerrrrrr]rrrrs D +.++5;H:76;9'  @@F"J vJ  vr #r