BVh} dZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl mZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddl#m$Z$ddl#m%Z%ddl#m&Z&ddl'm(Z(ddl)m*Z*ddl)m+Z+ddl)m,Z,ddl)m-Z-ddl)m.Z.ddl/m0Z0dd l1m2Z2dd!l3m4Z4dd"l5m6Z6dd#l5m7Z7dd$l5m8Z9dd%l:m;Z;dd&lm?Z?dd(l>m@ZAdd)l>mBZBdd*lCmDZDdd+lEmFZFGd,d-e jZGGd.d/ejd/gd0ZIe"jZJy)1z=Contains the base Layer class, from which all layers inherit.N)ag_ctx)api)distribute_lib)context)dtypes)errors) func_graph)ops) sparse_tensor)tensor)tensor_conversion) tensor_util)backend) constraints) initializers) regularizers) base_layer)base_layer_utils) input_spec)autocast_variable)loss_scale_optimizer)policy)layer_serialization) generic_utils) layer_utils)object_identity) tf_inspect)tf_utils) to_snake_case)is_tensor_or_tensor_list)module) array_ops)math_ops) variables) ragged_tensor) tf_logging) autotrackable)base)data_structures)nest) doc_controlsc ~eZdZdZeej dejjZ e jdddZ e je jdZej"dZej"dZej"dddddddddej*j,ej.j0f dZe jd Zed Zd Zej"d Ze jded ZdZ dZ!e"dZ#e"dZ$e"dZ%e"ejLdZ'e'jPdZ'e"dZ)e)jPdZ)e"dZ*e*jPdZ*e"dZ+e+jPe jdZ+e"dZ,e"dZ-ej"dedZ.e"dZ/ej"dfdZ0ej"ded Z1d!Z2d"Z3d#Z4d$Z5d%Z6d&Z7e"d'Z8e"d(Z9d)Z:d*Z;d+Ze"d.Z?e"d/Z@d0ZAe"d1ZBe"ejd2ZDe"ejd3ZEejd4ZFejd5ZGe"d6ZHe"d7ZIe"d8ZJe"d9ZKeKjPe jd:ZKe"d;ZLeLjPe jd<ZLd=ZMe"d>ZNd?ZOe"d@ZPePjPdAZPdBZQdgdCZRdedDZSdfdEZTdFZUdGZVdHZWdIZXdhdJZYdhdKZZ didLZ[dMZ\dNZ]dOZ^dPZ_dQZ`e"dRZae jdSZbfdTZcfdUZddVZededWZfe"egjdXZie"egjdYZje"egjdZZke"egjd[Zle"egjd\Zmd]Zne"d^Zoe"d_Zpe"d`Zqdjfda ZrdbZsdcZtxZuS)kLayera Base layer class. This is the class from which all layers inherit. A layer is a class implementing common neural networks operations, such as convolution, batch norm, etc. These operations require managing weights, losses, updates, and inter-layer connectivity. Users will just instantiate a layer and then treat it as a callable. We recommend that descendants of `Layer` implement the following methods: * `__init__()`: Save configuration in member variables * `build()`: Called once from `__call__`, when we know the shapes of inputs and `dtype`. Should have the calls to `add_weight()`, and then call the super's `build()` (which sets `self.built = True`, which is nice in case the user wants to call `build()` manually before the first `__call__`). * `call()`: Called in `__call__` after making sure `build()` has been called once. Should actually perform the logic of applying the layer to the input tensors (which should be passed in as the first argument). Args: trainable: Boolean, whether the layer's variables should be trainable. name: String name of the layer. dtype: The dtype of the layer's computations and weights (default of `None` means use `tf.keras.backend.floatx` in TensorFlow 2, or the type of the first input in TensorFlow 1). dynamic: Set this to `True` if your layer should only be run eagerly, and should not be used to generate a static computation graph. This would be the case for a Tree-RNN or a recursive network, for example, or generally for any layer that manipulates tensors using Python control flow. If `False`, we assume that the layer can safely be used to generate a static computation graph. Attributes: name: The name of the layer (string). dtype: The dtype of the layer's computations and weights. If mixed precision is used with a `tf.keras.mixed_precision.Policy`, this is instead just the dtype of the layer's weights, as the computations are done in a different dtype. 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). 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. Each layer has a dtype, which is typically the dtype of the layer's computations and variables. A layer's dtype can be queried via the `Layer.dtype` property. The dtype is specified with the `dtype` constructor argument. In TensorFlow 2, the dtype defaults to `tf.keras.backend.floatx()` if no dtype is passed. `floatx()` itself defaults to "float32". Additionally, layers will cast their inputs to the layer's dtype in TensorFlow 2. When mixed precision is used, layers may have different computation and variable dtypes. See `tf.keras.mixed_precision.Policy` for details on layer dtypes. )_obj_reference_counts_dictNc |jhd}tj||||_d|_d|_d|_d|_d|_|j|tj|jdd|_ |jdg|jdgg|_t!j"|_g|_g|_g|_|j-||jdt/j0|_|jdgg|_g|_|j9||_d|vr d |vr |df|d <d |vsd |vrweightsautocast input_dim batch_size input_shapeimplementationbatch_input_shapeactivity_regularizerFr7_trainable_weights_non_trainable_weightsr1_self_tracked_trackablesr2r4r6r3r0T)$_instrument_layer_creationrvalidate_kwargs _trainable _statefulbuilt_build_input_shape _input_specsupports_masking_init_set_namergetpop_activity_regularizer_maybe_create_attribute_updates threadinglocal _thread_local_callable_losses_losses_metrics_set_dtype_policyrv2_dtype_behavior_enabled _autocast_inbound_nodes_value_outbound_nodes_value_init_call_fn_args_dynamictuple_batch_input_shape_initial_weights_auto_track_sub_layers_originally_built_as_v1#_preserve_input_structure_in_config) self trainablenamedtypedynamickwargsallowed_kwargsr6r3s \/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/keras/engine/base_layer_v1.py__init__zLayer.__init__s  ##% N !!&.9  DODNDJ"DD!D!-!1!1 )40"2D  !5r:  !92>DM"*DDDLDM 5!ZZ 0 J J LNDN    !;R@ !#D!#D DMff!<%k24f]"5"?  &!&)<"=> F " 6 !l+**'ME&2G,HH 1d#JJy$7D#'D$(D 05D,cLt|jds||_d|_y)aCreates the variables of the layer (optional, for subclass implementers). This is a method that implementers of subclasses of `Layer` or `Model` can override if they need a state-creation step in-between layer instantiation and layer call. This is typically used to create the weights of `Layer` subclasses. Args: input_shape: Instance of `TensorShape`, or list of instances of `TensorShape` if the layer expects a list of inputs (one instance per input). _is_defaultTN)hasattrbuildr@r?)r\r4s rcriz Layer.builds! 4::} - +dDJrec |S)zThis is where the layer's logic lives. Args: inputs: Input tensor, or list/tuple of input tensors. **kwargs: Additional keyword arguments. Returns: A tensor or list/tuple of tensors. )r\inputsras rccallz Layer.calls  Mrect|tjr|}ntj|}|r|jj ||S|j j ||S)aAdds a Trackable object to this layer's state. Args: trackable_object: The tf.tracking.Trackable object to add. trainable: Boolean, whether the variable should be part of the layer's "trainable_variables" (e.g. variables, biases) or "non_trainable_variables" (e.g. BatchNorm mean and variance). Returns: The TrackableWeightHandler used to track this object. ) isinstancerTrackableWeightHandlerr8appendr9)r\trackable_objectr]handlers rc_add_trackablezLayer._add_trackable&se"$4$K$KL g 778HIg $$W- N !!((1 Nrec  |d}| D]} | dvstd| d| v}| jdtj}| jdd}| jdd}| jd d}|"|jxst j }tj|}|jj8|jtj|jjt!j"|}t%j"|}t'j"|}| t(j*j,k(r|r t/d d }n|d}||j0rt!j"d }nc|j2s|j4s |j6rt!j8}n*|s(t/d |d|jd|j|rY|jj:|jjk7r,|j0r |fd}|t=j>dd}|jA|||d|||||| || | |}|;|jd|jjCd}|jE|||tjF|rW|D]P}t jH||r|jJjM|6|jNjM|R|St jH||r|jJjM||S|jNjM||S)aAdds a new variable to the layer. Args: name: Variable name. shape: Variable shape. Defaults to scalar if unspecified. dtype: The type of the variable. Defaults to `self.dtype` or `float32`. initializer: Initializer instance (callable). regularizer: Regularizer instance (callable). trainable: Boolean, whether the variable should be part of the layer's "trainable_variables" (e.g. variables, biases) or "non_trainable_variables" (e.g. BatchNorm mean and variance). Note that `trainable` cannot be `True` if `synchronization` is set to `ON_READ`. constraint: Constraint instance (callable). partitioner: Partitioner to be passed to the `Trackable` API. 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`. **kwargs: Additional keyword arguments. Accepted values are `getter`, `collections`, `experimental_autocast` and `caching_device`. 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 giving unsupported dtype and no initializer or when trainable has been set to True with synchronization set as `ON_READ`. Nrk)getter collectionsexperimental_autocastcaching_devicezUnknown keyword argument:rvrwrxTryzSynchronization value can be set to VariableSynchronization.ON_READ only for non-trainable variables. You have specified trainable=True and synchronization=VariableSynchronization.ON_READ.Fglorot_uniformzAn initializer for variable z of type z is required for layer c>|i|}tj|SN)rcreate_autocast_variable)argsravariable old_getters rcrvz Layer.add_weight..getters#t.v. 99(CCrezb`caching_device` does not work with mixed precision API. Ignoring user specified `caching_device`.)r^shaperv overwrite initializerr_ constraintr] partitioner use_resourcerwsynchronization aggregationry:)( TypeErrorrEr make_variabler_rfloatxras_dtype _dtype_policyvariable_dtyperOrPolicy base_dtyper^rrDrr tf_variablesVariableSynchronizationON_READ ValueError is_floating is_integer is_unsignedis_boolzeros compute_dtyper&warning _add_variable_with_custom_getterfind_handle_weight_regularizationis_split_variabletrack_variabler8rqr9)r\r^rr_r regularizerr]rrrrrrakwarghas_custom_getterrvcollections_argr1ryr name_in_scopevrs @rc add_weightzLayer.add_weight=sRj }e< ) )3U;;<!F* ZZ"2"@"@ AFjj5Ozz148HZZ 0$7N }jj,GNN,e OOE "E ((0 V]]5+;+;+@+@AB"";/K"";/K,J,>>FFF  ?@ @  i   "&&'78    u00EMM"((*  ,0%2B2BDIIOP P  ((D,>,>,M,MM   jD  # / 044 !#'%#5'H$mm$z,Layer.compute_output_shape..Bs !''re)rexecuting_eagerly _maybe_buildr get_default_graph as_defaultr FuncGraphrconvert_shapesr* map_structurer generate_placeholders_from_shaperr __class____name__)r\r4rrloutputses rccompute_output_shapezLayer.compute_output_shapes   "  $  " - - / 0$$W-     0 // uM+%%??N& 06E2G 0 0   17 ;;  0%D''()/0  0 0 0 0 0 0sB&D#..check_type_return_shape[s8 6,, -77=vayB B WWnrerc2tj|S)N)r_r)r r)rr_s rcrz0Layer.compute_output_signature..is&##%q9re)r*rr_compute_dtypeflattenr_)r\input_signaturerr4 output_shaper input_dtypesr_s @rccompute_output_signaturezLayer.compute_output_signatureEs, $$%z%Layer.compute_mask..ys 7qQd] 7sLayer z9 does not support masking, but was passed an input_mask: N)rBanyr*rrr^str)r\rlmasks rc compute_maskzLayer.compute_masklsa  7DLL$6 7 7499,099;>t9EF F Krec Z |jt|ds td|r |d}|dd}n;|jd|vr|j |jd}n t dt j}tj|}tj|}td|Dr.d}tj||}tj|}d }|j|||} |jr| |j!d ||sd }| |d <d} d } |j!d ||r0|j#d ||} |j$s|j d | |j& |j&} n~t)j*rt)j,} nU|rSt)j.j15t j2rt)j,} ddd|j$r`| ^t5j6| r%t9j:| t<j>} n t?| } |jAd | ||\}}d } |r*t jB|rt jD||jG|||| 5|r)tIjJ|jH||jLt)j.} | j15t)jN|jQ5|jS||jU|} t jV|rHt jX|s3t[j\|j^tajb}n |j^}|jds6 tgjh|jj5|| g|i|}dddn|ju|}t d|jLzdzt jv|rE| r|jAd d||d \}}|r|j d |jy|f|z||}|j{|||j}||| t|dr|j~s|j||ddddddnt)jN|jQ5|jS||jU|} tgjh|jj5|j^| g|i|}ddd|j{||j}||| ddddddS#1swYxYw#1swYxYw#tljn$r}tqd ts|zdzd}~wwxYw#1swYxYw#1swYoxYw#1swYxYw#1swYxYw#1swYSxYw)aWraps `call`, applying pre- and post-processing steps. Args: *args: Positional arguments to be passed to `self.call`. **kwargs: Keyword arguments to be passed to `self.call`. Returns: Output tensor(s). Note: - The following optional keyword arguments are reserved for specific uses: * `training`: Boolean scalar tensor of Python boolean indicating whether the `call` is meant for training or inference. * `mask`: Boolean input mask. - 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). RuntimeError: if `super().__init__()` was not called in the constructor. rKz.s" Gq:a"**eS1 2 Gs/1czt|tjttfrt j |S|Sr|)rorrrrr "convert_to_tensor_v2_with_dispatchrs rc_convert_non_tensorz+Layer.__call__.._convert_non_tensors/ a"**eS1 2"EEaH HreFrTrzYou are attempting to use Python control flow in a layer that was not declared to be dynamic. Pass `dynamic=True` to the class constructor. Encountered error: """ z """zVA layer's `call` method should return a Tensor or a list of Tensors, not None (layer: z).)pop_kwarg_if_none _set_inputs)A_assert_built_as_v1rh RuntimeError _call_fn_argsrErr call_contextr*rrare_all_symbolic_tensorsrr_collect_input_masks_expects_mask_arg_call_arg_was_passed_get_call_arg_value_expects_training_argrrglobal_learning_phase_is_setlearning_phase get_graphris_in_keras_graphr is_tf_typer#castrbool_set_call_arg_valueneeds_keras_historycreate_keras_historyenterrassert_input_compatibilityr^ name_scope _name_scoper_maybe_cast_inputs is_subclassedfrom_saved_model autograph tf_convertrmrcontrol_status_ctxr`renable_auto_cast_variables_compute_dtype_objectrOperatorNotAllowedInGraphErrorrr_symbolic_callhave_all_keras_metadata_set_connectivity_metadata_handle_activity_regularization_set_mask_metadatarlr)r\r~rarlr input_list build_graphrmask_arg_passed_by_framework input_maskstraining_value training_arg_passed_by_frameworkr cast_inputscall_fnrrs rc__call__zLayer.__call__s2  4 )  H JJ Awf !"Xd  A & (zz$,,Q/0f  E GG$002Lf%J 33J?K GJ GG !!"5v>f<<'j $) ++FD&AK ;#:  % %fdF ;%)""fVnN',$   T6:// D&In  ' ' :    *%..  / / 1 //1     + + - 6  / / 1$335N 6  # #(B  ! !. 1#==E./.// f6 f+/( ';;FC++F3   D&+~ FN@  --doov.2ii 9!!#    < .!3!3D4D4D4F!G< .   F #//7+,,T2"33D9** 64468GiiG 0$??,,.@!+???@"))&1G _(*.))46:;< < 5 5f =/!55dD&D6JldF+jj 55vi$6F6=?G  . .vw ?  ! !&'; ? T= )$++   VW -y< .< .< .~   0 0 2 3 @   F #//7+ ;;((* >dii =d=f=G >  . .vw ?  ! !&'; ? @ON@` NK 6 6d@@88 0H"!f %(/ /00 03< .< .< .< .D > > @ @ON@` Ns)V 8AX  $W</BW/V:' V- 4V:.^sB%u~~Br_flatten_layersr&s rcr`z Layer.dynamic\s B4+?+?+AB BBrecBtd|jDS)Nc34K|]}|jywr|r>r-s rcrz!Layer.stateful..csC5uCr/r0r&s rcstatefulzLayer.stateful`s CD,@,@,BC CCrec||_yr|r4r\values rcr5zLayer.statefules DNrec|jSr|)r=r&s rcr]zLayer.trainableis ??recD||_t|dgD] }||_ y)Nr:)r=getattrr])r\r8r.s rcr]zLayer.trainablems)DO92>eorec|jS);Optional regularizer function for the output of this layer.rFr&s rcr7zLayer.activity_regularizerss  % %%rec||_y)r=Nr>)r\rs rcr7zLayer.activity_regularizerxs "-Drec|jSr|)rAr&s rcrzLayer.input_spec}s   rectj|D]9}|t|tjr!t dj |||_y)Nz:Layer input_spec must be an instance of InputSpec. Got: {})r*rror InputSpecrrrA)r\r8rs rcrzLayer.input_specsU \\% - z!Z-A-AB""(&)- --Drecg}|j}tjj5|D]g}|js |j s|j D]=}t|r |}tj|d|j|?i ddd|S#t$r4}dt|jvrtjddd}~wwxYw#1swY|SxYw)NInaccessibleTensorError add_updateT)method force_raiserF)r1rrrr]r5rHcallablerr%rrcheck_graph_consistencyrq)r\collected_updates all_layersr.urs rcupdatesz Layer.updatess%%'J     ' ' )&&%u~~  &A a[ #a  2 21\ J  " "1 % &&&(  *d1g.>.>> !88'T; &( s/9C-/B-6,C-- C* 6/C% %C* *C--C7cg}|j}|D]I}|j|j|jD]}|}| |j |K|S)a3Losses which are associated with this `Layer`. Variable regularization tensors are created when this property is accessed, so it is eager safe: accessing `losses` under a `tf.GradientTape` will propagate gradients back to the corresponding variables. Returns: A list of tensors. )r1extendrMrLrq)r\collected_lossesrLr.r loss_tensors rclossesz Layer.lossesss%%'J/emm,///+!m  "  ! !+ ./ / rec$fd}tj|}g}g}|D]}t|r&|jt j ||4|7t j|s)tj|tj}tj|stjr|j||tj |d|j"j%|tj&j(}|r#|D]}|j*j|y|D]<}t-|ddr|j/|"|j*j|>y)ac Add loss tensor(s), potentially dependent on layer inputs. Some losses (for instance, activity regularization losses) may be dependent on the inputs passed when calling a layer. Hence, when reusing the same layer on different inputs `a` and `b`, some entries in `layer.losses` may be dependent on `a` and some on `b`. This method automatically keeps track of dependencies. This method can be used inside a subclassed layer or model's `call` function, in which case `losses` should be a Tensor or list of Tensors. Example: ```python class MyLayer(tf.keras.layers.Layer): def call(inputs, self): self.add_loss(tf.abs(tf.reduce_mean(inputs)), inputs=True) return inputs ``` This method can also be called directly on a Functional Model during construction. In this case, any loss Tensors passed to this Model must be symbolic and be able to be traced back to the model's `Input`s. These losses become part of the model's topology and are tracked in `get_config`. Example: ```python inputs = tf.keras.Input(shape=(10,)) x = tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) model = tf.keras.Model(inputs, outputs) # Activity regularization. model.add_loss(tf.abs(tf.reduce_mean(x))) ``` If this is not the case for your loss (if, for example, your loss references a `Variable` of one of the model's layers), you can wrap your loss in a zero-argument lambda. These losses are not tracked as part of the model's topology since they can't be serialized. Example: ```python inputs = tf.keras.Input(shape=(10,)) x = tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Dense(1)(x) model = tf.keras.Model(inputs, outputs) # Weight regularization. model.add_loss(lambda: tf.reduce_mean(x.kernel)) ``` The `get_losses_for` method allows to retrieve the losses relevant to a specific set of inputs. Args: losses: Loss tensor, or list/tuple of tensors. Rather than tensors, losses may also be zero-argument callables which create a loss tensor. inputs: Ignored when executing eagerly. If anything other than None is passed, it signals the losses are conditional on some of the layer's inputs, and thus they should only be run where these inputs are available. This is the case for activity regularization losses, for instance. If `None` is passed, the losses are assumed to be unconditional, and will apply across all dataflows of the layer (e.g. weight regularization losses). ct|r%tjd5|}ddd|ytj|s)t j |tj}du|_ |S#1swYUxYw)z@Process the loss and tag it by setting loss._unconditional_loss.Nr_) rIrrrrr rrr_unconditional_loss)lossrls rc_tag_unconditionalz*Layer.add_loss.._tag_unconditionals{ $ 9 9$ ? $    # #D ) CC ( #)D.d k  s A>>BNrVadd_lossrH_is_graph_networkF)r*rrIrq functoolspartialrrr rrrris_symbolic_tensorris_in_tf_functionrJrLrPrin_callrMr;_graph_network_add_loss) r\rSrlrYcallable_lossessymbolic_lossesrXin_call_context symbolic_losss ` rcrZzLayer.add_losssZH \\& !FOOJ $y001CTJK   # #D ) CC (   % %d +0021$7800jIJ    1&335==O*+- M*++-- 4,e 4  & &} 5 ,,  m , -recjg}|jD]}|j|j|Sr|)r1rPrN)r\collected_metricsr.s rcmetricsz Layer.metrics5s8%%'/u~~./ recH||dk7rtd|zt|d}tj|}t j j }| |s td|r|jj}|r|j|||y|stdt|zt|dds?tjj5|j|||dddy|r td |j|||y#1swYyxYw) aAdds metric tensor to the layer. Args: value: Metric tensor. aggregation: Sample-wise metric reduction function. If `aggregation=None`, it indicates that the metric tensor provided has been aggregated already. eg, `bin_acc = BinaryAccuracy(name='acc')` followed by `model.add_metric(bin_acc(y_true, y_pred))`. If aggregation='mean', the given metric tensor will be sample-wise reduced using `mean` function. eg, `model.add_metric(tf.reduce_sum(outputs), name='output_mean', aggregation='mean')`. name: String metric name. Raises: ValueError: If `aggregation` is anything other than None or `mean`. Nmeanz^We currently support only `mean` sample-wise metric aggregation. You provided aggregation=`%s` _metric_objzPlease provide a name for your metric like `self.add_metric(tf.reduce_sum(inputs), name='mean_activation', aggregation='mean')`z;Expected a symbolic Tensor for the metric value, received: r[FzUsing the result of calling a `Metric` object when calling `add_metric` on a Functional Model is not supported. Please pass the Tensor to monitor directly.)rrhrr^rrr`rkr^_symbolic_add_metricrr;rrr_graph_network_add_metric)r\r8rr^from_metric_obj is_symbolicrds rc add_metriczLayer.add_metric<s<$;  *,7 8 99e]3O--e4K&335==O |O J KK     # #d {D9 &(+E 34 4T. 6    + + - >  # #E; = > 78 8  $$UK> >s DD!c|tjdtj}t j r!t j r |jsytj|}|jr |jn't|dg}|Dcgc]}|jc}fd|Dcgc] }| }}|jj|ycc}wcc}w)a3Add update op(s), potentially dependent on layer inputs. Weight updates (for instance, the updates of the moving mean and variance in a BatchNormalization layer) may be dependent on the inputs passed when calling a layer. Hence, when reusing the same layer on different inputs `a` and `b`, some entries in `layer.updates` may be dependent on `a` and some on `b`. This method automatically keeps track of dependencies. The `get_updates_for` method allows to retrieve the updates relevant to a specific set of inputs. This call is ignored when eager execution is enabled (in that case, variable updates are run on the fly and thus do not need to be tracked for later execution). Args: updates: Update op, or list/tuple of update ops, or zero-arg callable that returns an update op. A zero-arg callable should be passed in order to disable running the updates by setting `trainable=False` on this Layer, when executing in Eager mode. inputs: Deprecated, will be automatically inferred. Nz`add_update` `inputs` kwarg has been deprecated. You no longer need to pass a value to `inputs` as it is being automatically inferred._inbound_nodesctr fd}|Sttjr}n.t dr j }nt j}tj|g}||v|_ |S)zuStandardize update ops. Args: x: Tensor, op, or callable. Returns: An update op. cSr|rk)process_updatersrcrz:Layer.add_update..process_update..s,reop) rIror Operationrhrvr rrget_reachable_from_inputs_unconditional_update)rupdate reachablerurelevant_inputss` rcruz(Layer.add_update..process_updatest !,x a ' 1d "EEaH44_vhOi%+9%>> a = tf.keras.layers.Dense(1, ... kernel_initializer=tf.constant_initializer(1.)) >>> a_out = a(tf.convert_to_tensor([[1., 2., 3.]])) >>> a.get_weights() [array([[1.], [1.], [1.]], dtype=float32), array([0.], dtype=float32)] >>> b = tf.keras.layers.Dense(1, ... kernel_initializer=tf.constant_initializer(2.)) >>> b_out = b(tf.convert_to_tensor([[10., 20., 30.]])) >>> b.get_weights() [array([[2.], [2.], [2.]], dtype=float32), array([0.], dtype=float32)] >>> b.set_weights(a.get_weights()) >>> b.get_weights() [array([[1.], [1.], [1.]], dtype=float32), array([0.], dtype=float32)] Args: weights: a list of Numpy arrays. The number of arrays and their shape must match number of the dimensions of the weights of the layer (i.e. it should match the output of `get_weights`). Raises: ValueError: If the provided weights list does not match the layer's specifications. rrz,You called `set_weights(weights)` on layer "z" with a weight list of length z, but the layer was expecting z weights. Provided weights: N2z...rrkzLayer weight shape z+ not compatible with provided weight shape )r0rorrp num_tensorsrrr^r set_weightsrhris_compatible_withrqrbatch_set_value) r\r0paramsexpected_num_weightsparam weight_indexweight_value_tuplesrtensorsweight weight_shape ref_shapes rcrzLayer.set_weightssnX\\F" E+BB C 1 11! " s7|+  99c'l$8#g,s:K M NN L E+BB C'' ,|k'AB '" # &'.vw'?v||R KK ++L9%|56 6 ""E6?3 " /0rec|j}g}|D]M}t|tjr |j |j =|j |Otj|S)aReturns the current weights of the layer. The weights of a layer represent the state of the layer. This function returns both trainable and non-trainable weight values associated with this layer as a list of Numpy arrays, which can in turn be used to load state into similarly parameterized layers. For example, a Dense layer returns a list of two values-- per-output weights and the bias value. These can be used to set the weights of another Dense layer: >>> a = tf.keras.layers.Dense(1, ... kernel_initializer=tf.constant_initializer(1.)) >>> a_out = a(tf.convert_to_tensor([[1., 2., 3.]])) >>> a.get_weights() [array([[1.], [1.], [1.]], dtype=float32), array([0.], dtype=float32)] >>> b = tf.keras.layers.Dense(1, ... kernel_initializer=tf.constant_initializer(2.)) >>> b_out = b(tf.convert_to_tensor([[10., 20., 30.]])) >>> b.get_weights() [array([[2.], [2.], [2.]], dtype=float32), array([0.], dtype=float32)] >>> b.set_weights(a.get_weights()) >>> b.get_weights() [array([[1.], [1.], [1.]], dtype=float32), array([0.], dtype=float32)] Returns: Weights values as a list of numpy arrays. ) r0rorrprP get_tensorsrqrbatch_get_value)r\r0output_weightsrs rc get_weightszLayer.get_weightsskFllGN& F,CC Df0023f% &  " "> 22rec>|'|jDcgc]}|js|c}S|jDcgc]}|jr|}}tj|}t j ||}|Dcgc] }||vs| c}Scc}wcc}wcc}w)zRetrieves updates relevant to a specific set of inputs. Args: inputs: Input tensor or list/tuple of input tensors. Returns: List of update ops of the layer that depend on `inputs`. )rNryr*rrrx)r\rlrMrNr{s rcget_updates_forzLayer.get_updates_forFs~ AA)@)@a AA,,FQa.E.EqFGF \\& !F2267CI 1!!y.A 11 BG 2!BBB B? B Bc>|'|jDcgc]}|js|c}S|jDcgc]}|jr|}}tj|}t j ||}|Dcgc] }||vs| c}Scc}wcc}wcc}w)zRetrieves losses relevant to a specific set of inputs. Args: inputs: Input tensor or list/tuple of input tensors. Returns: List of loss tensors of the layer that depend on `inputs`. )rSrWr*rrrx)r\rllrSr{s rcget_losses_forzLayer.get_losses_forYs~ >A(=(=a >> BAA,A,Aa BF B \\& !F2266BI 0!iA 00 ?C 1rc|j|}t|tr|Dcgc]}t|ddc}St|ddScc}w)avRetrieves the input mask tensor(s) of a layer at a given node. Args: node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. Returns: A mask tensor (or list of tensors if the layer has multiple inputs). _keras_maskN) get_input_atrolistr;)r\ node_indexrlrs rcget_input_mask_atzLayer.get_input_mask_atlsL  z *F&$7= >!ga- >> V]D 11?A c|j|}t|tr|Dcgc]}t|ddc}St|ddScc}w)axRetrieves the output mask tensor(s) of a layer at a given node. Args: node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. Returns: A mask tensor (or list of tensors if the layer has multiple outputs). rN) get_output_atrorr;)r\routputrs rcget_output_mask_atzLayer.get_output_mask_atsL   +F&$7= >!ga- >> V]D 11?rc|j}t|tr|Dcgc]}t|ddc}St|ddScc}w)aqRetrieves the input mask tensor(s) of a layer. Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer. Returns: Input mask tensor (potentially None) or list of input mask tensors. Raises: AttributeError: if the layer is connected to more than one incoming layers. rN)inputrorr;)r\rlrs rc input_maskzLayer.input_masksEZZF&$7= >!ga- >> V]D 11?Ac|j}t|tr|Dcgc]}t|ddc}St|ddScc}w)atRetrieves the output mask tensor(s) of a layer. Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer. Returns: Output mask tensor (potentially None) or list of output mask tensors. Raises: AttributeError: if the layer is connected to more than one incoming layers. rN)rrorr;)r\rrs rc output_maskzLayer.output_masksE[[F&$7= >!ga- >> V]D 11?rc(|j|ddS)aRetrieves the input shape(s) of a layer at a given node. Args: node_index: Integer, index of the node from which to retrieve the attribute. E.g. `node_index=0` will correspond to the first time the layer was called. Returns: A shape tuple (or list of shape tuples if the layer has multiple inputs). Raises: RuntimeError: If called in Eager mode. input_shapesz input shape_get_node_attribute_at_indexr\rs rcget_input_shape_atzLayer.get_input_shape_ats  , ,Z-: <9&& '' AsBcT|jsrt|ddr:tj|5|j |j dddn+t d|jzdz|jzdztj|jS#1swY(xYw)zCount the total number of scalars composing the weights. Returns: An integer count. Raises: ValueError: if the layer isn't yet built (in which case its weights aren't yet defined). r[FNz$You tried to call `count_params` on z=, but the layer isn't built. You can build it manually via: `z.build(batch_input_shape)`.) r?r;rmaybe_init_scoperrlrr^r count_paramsr0r&s rcrzLayer.count_paramsLs :: *E 2  & &t , )   DKK ( ) )?$))K<<>BiiH778 8  # #DLL 11 ) )s BB'c$|js tdt|jDcgc]}t|jc}}t |dk(r|jdjStd|j zcc}w)aRetrieves the output shape(s) of a layer. Only applicable if the layer has one output, or if all outputs have the same shape. Returns: Output shape, as an integer shape tuple (or list of shape tuples, one tuple per output tensor). Raises: AttributeError: if the layer has no defined output shape. RuntimeError: if called in Eager mode. zEThe layer has never been called and thus has no defined output shape.rrzThe layer "%s" has multiple inbound nodes, with different output shapes. Hence the notion of "output shape" is ill-defined for the layer. Use `get_output_shape_at(node_index)` instead.)rrrrrrrr^)r\rall_output_shapess rcrzLayer.output_shapeas    C DD-1-@-@ATT   AC "   # 1 11 & )- 2 33 BsB c|jSzCDeprecated, do NOT use! Only for compatibility with external Keras.)rrr&s rcrzLayer.inbound_nodess   rec|jSr)_outbound_nodesr&s rcoutbound_nodeszLayer.outbound_nodess   recXtjd|j|g|i|S)a*Deprecated, do NOT use! This is an alias of `self.__call__`. 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`. Returns: Output tensor(s). zp`layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.)warningswarnr#)r\rlr~ras rcapplyz Layer.applys4 MM@A 4== 1$ 1& 11recPtjd|j|i|S)z/Deprecated, do NOT use! Alias for `add_weight`.zy`layer.add_variable` is deprecated and will be removed in a future version. Please use `layer.add_weight` method instead.)rrr)r\r~ras rc add_variablezLayer.add_variables/ MMBC 4??D +F ++rec|jS)z|Returns the list of all layer variables/weights. Alias of `self.weights`. Returns: A list of variables. )r0r&s rcr$zLayer.variabless <<rec|jSr|)trainable_weightsr&s rctrainable_variableszLayer.trainable_variabless  ! !!rec|jSr|)non_trainable_weightsr&s rcnon_trainable_variableszLayer.non_trainable_variables  % %%rec|jSr|rRr&s rcrrzLayer._inbound_nodess  $ $$rec||_yr|rr7s rcrrzLayer._inbound_nodess !&Drec|jSr|rSr&s rcrzLayer._outbound_nodesrrec||_yr|rr7s rcrzLayer._outbound_nodess "'Drec0t|tjr||_nt|trtj ||_nt|t r|dvrtj||_nS|r8tjtj|j|_ntj|_|jjdk(rbtjsNtj}td|j j"d|jjd|jj$r/tj|jj$|_yd|_y)zSets self._dtype_policy.) mixed_float16mixed_bfloat16rzBMixed precision is not supported with the tf.distribute.Strategy: z@. Either stop using mixed precision by removing the use of the "z>" policy or use a different Strategy, e.g. a MirroredStrategy.N)rorrrdict deserializerrrr^ global_policyrstrategy_supports_loss_scalingr get_strategyrrrrr)r\r_strategys rcrOzLayer._set_dtype_policys3%' d E4 !--e4d E3 E.@%@"==/d !==)?)D)DEd!//1d ?2 ? ? A  ,,.h !**33T5G5G5L5L N OO ''#)??    * *$,d $(d rec.|jjS)zThe layer's compute dtype. Unless mixed-precision is used, this is the same as `Layer.dtype`. If self._autocast is True, layer's will cast floating-point inputs to this. Returns: The layer's compute dtype. )rrr&s rcrzLayer._compute_dtypes    + ++rec|j|jr<r:tjjrfd}t j ||S|S)aTMaybe casts the inputs to the compute dtype. If self._compute_dtype is floating-point, and self_autocast is True, floating-point inputs are casted to self._compute_dtype. Args: inputs: Input tensor, or structure of input tensors. Returns: `inputs`, but tensors may have been casted to self._compute_dtype ctjtjtj f}t ||rO|jjr9|jjjk7rtj|St |tjrA|jjr+tj|j|jS|S)z8Cast a single Tensor or TensorSpec to the compute dtype.)r Tensorr SparseTensorr% RaggedTensorror_rrr^r#rrr)r cast_typesrs rcfz#Layer._maybe_cast_inputs..fsmm]%?%?#002 q* %!''*=*= GG   # #} 4q-0 0 6,, -!''2E2E""177M166B B(re)rrQrrrr*r)r\rlrrs @rcr zLayer._maybe_cast_inputssJ''M = &22   6 ** mrec.|jjSr|r(r&s rc_dtypez Layer._dtype)s    , ,,rectj|j}|jt j |yr|)rrr^rOrrr7s rcrz Layer._dtype0s- OOE " ' 'E6==/0rec|jSr|)r^r&s rcr zLayer._name_scope5s 99rec|sDtjtj|jj ||_y||_y)N) zero_based)runique_object_namerrrrr*)r\r^rs rcrCzLayer._init_set_name8s; --  % %dnn&=&= >!djdjrec|jDcgc]}|j|k(s|}}|syt|dkDr$tdj t|||dScc}w)NrzfPlease provide different names for the metrics you have added. We found {} metrics with the name: "{}"r)rNr^rrr)r\r^rmatchs rc_get_existing_metriczLayer._get_existing_metric@sh 814Q 8E 8   5zA~  44:F3u:t4L NN 8O 9s A$A$cjtj|d|j|}|H|r|}|}yt|dr*|}|j}|j j |ytd|r ||}|}ytj||\}}|j j |y)NrprHrkaWe do not support adding an aggregated metric result tensor that is not the output of a `tf.keras.metrics.Metric` metric instance. Without having access to the metric instance we cannot reset the state of a metric after every epoch during training. You can create a `tf.keras.metrics.Metric` instance and pass the result here or pass an un-aggregated result with `aggregation` parameter set as `mean`. For example: `self.add_metric(tf.reduce_sum(inputs), name='mean_activation', aggregation='mean')`) rrJrrhrkrNrqrcreate_mean_metric)r\r8rr^r result_tensor metric_objs rcrlzLayer._symbolic_add_metricJs,,U<H  % %d +E   5- ( "..  Z( AB B e  $4$G$G 4%! M Z(recfd}tj|r-|D]'}|jtj||)y|jtj||y)z3Create lambdas which compute regularization losses.cttjdz5|}ddd|S#1swYSxYw)z8Creates a regularization loss `Tensor` for variable `v`.z /RegularizerN)rr )rregularizationr^rs rc_loss_for_variablez?Layer._handle_weight_regularization.._loss_for_variablers;   d^3 4($Q( ( s -7N)rrrZr\r])r\r^rrrrs ` ` rcrz#Layer._handle_weight_regularizationos_ ))(3@! i''(:A>?@ mmI%%&8(CDrec|jrtj|}tjd5|D]x}|j|}t j tj|d|j}||z }tj|d|j||z dddyy#1swYyxYw)NActivityRegularizerrr7rH)rl) rFr*rrr r#rr"rr_rrJrZ)r\rlr output_listr activity_lossr3mean_activity_losss rcrz%Layer._handle_activity_regularization~s !!LL)k   3 4 ;! ;F44V<-}}oof%a(-*=*=?* -z9   2 2 )? A --*6- : ; ; ;" ; ;s A>CC ctj|}t|ddxstd|D}t |dxr&|j xst|j dd }|r|Dcgc]}t|dd}}nK|s|D cgc]} d}} n9|j ||} | |D cgc]} d}} ntj| }t||D] \} } | | _tj|r'|D]!} t| ddd| j_ #yycc}wcc} wcc} w#t$rYgwxYw)N _compute_output_and_mask_jointlyFc3:K|]}t|ddduyw)rNr;rs rcrz+Layer._set_mask_metadata..s NAGA}d +4 7 NsrrgrT) r*rr;allrhrBrziprrrr_keras_history_checked) r\rlr previous_mask flat_outputsmask_already_computedshould_compute_maskr flat_masks_ output_masksrrs rcrzLayer._set_mask_metadatasm<<(L 8%@ O N NN n% ?   > T&& u = = =IJGA}d3JjJ "./QD/j/&&v}=l  $01qd1 1\\,/ L*5  ! ((6 ;& 6=$ / ;6:&   3;7'K/ 2   s$1D, D12 D6&D;; EEc|jd||r|jd||S|jsytjd|}t j |ry|S)zDChecks if `mask` argument was passed, else gathers mask from inputs.rNct|ddS)Nrr rs rcrz,Layer._collect_input_masks..swq-/Nre)rr_should_compute_maskr*rr is_all_none)r\rlr~rars rcrzLayer._collect_input_maskssb   v6  % %fdF ;;  $ $ $$%N%+-K  -  recd||vry|j}|s|dd}|tt||vryy)NTrFrrr )r\arg_namer~rainputs_in_args call_fn_argss rcrzLayer._call_arg_was_passedsA6 %%L !!"%l4L$/00  recn||vr||S|j}|s|dd}tt||}||SNrr)r\rr~rarr args_dicts rcrzLayer._get_call_arg_valuesK6 H %%L !!"%lSt,-I X rec|jj|d}|)|s|dz }t||kDrt|}|||<||fS||r|j |d||fS|||<||fSr )_call_fn_arg_positionsrDrrrE)r\r new_valuer~rarrarg_poss rcrzLayer._set_call_arg_values))--h=G A+ TW Dz!W V|. jj4  <#fX <recl|jstd|zdzt|j|kDsBtd|zdzt |zdzt t|jzdzt |j||}t |trt|dk(r|dS|S) aPrivate utility to retrieves an attribute (e.g. inputs) from a node. This is used to implement the methods: - get_input_shape_at - get_output_shape_at - get_input_at etc... Args: node_index: Integer index of the node from which to retrieve the attribute. attr: Exact node attribute name. attr_name: Human-readable attribute name, for error messages. Returns: The layer's attribute `attr` at the node of index `node_index`. Raises: RuntimeError: If the layer has no inbound nodes, or if called in Eager mode. ValueError: If the index provided does not match any node. z8The layer has never been called and thus has no defined .z Asked to get z at node z, but the layer has only z inbound nodes.rr)rrrrrrr;ror)r\rattr attr_namevaluess rcrz"Layer._get_node_attribute_at_indexs.    46?@BEF GG t"" #j 0 2[@:')DE3t223457HI JJT((4d ;F&$CK1$4 AY mrec|js&tj|j||jt j |}|r^|j jH |djjj}|jtj|d}td|Drt jd|}t!|j"ds/t%j&|5|j#|dddt(j#|||j*#|j-|j*d|_yy#t$rYwxYw#1swY^xYw)Nrc34K|]}t|dyw)rN)rhrs rcrz%Layer._maybe_build..s 5QWQ 5r/c|jSr|rrs rcrz$Layer._maybe_build..s AGGrerg)r?rr r^r*rrrr_rrOrrrr rrhrirrr-rXr)r\rlrr_rs rcrzLayer._maybe_builds9 ::++ //6499.<<'j **88@ 7Q-%%0055%  u!5 6l 5* 5 5))*;VD TZZ / & &t , # **\ " #  kk$ % ( t,,-"d))    # #s'#E$E3$ E0/E03E<ctjd|}j|}fd}tj||S)Nc|jSr|rrs rcrz&Layer._symbolic_call..2s recXtj|j}d|_|S)N)rr_)r placeholderr_r)rphr\s rc_make_placeholder_likez4Layer._symbolic_call.._make_placeholder_like5s%   U$** =bbn ire)r*rr)r\rlrrr3s` rcrzLayer._symbolic_call1sA%%&7@L--l;M   4m DDrec|jdd}||ji}|D]!}|j|j#|S)z}Get the `trainable` state of each sublayer. Returns: A dict mapping all sublayers to their `trainable` value. F include_self recursive)r1r]rz_get_trainable_state)r\layerstrainable_staters rcr8zLayer._get_trainable_state<sS  ! !u ! FFT^^,O 7Q33567 rec||vr |||_|jdd}|D]}||vs|j|y)z(Set `trainable` state for each sublayer.Fr5N)r]r1_set_trainable_state)r\r:r9rs rcr<zLayer._set_trainable_stateHsP &t,dn  ! !u ! FF 0 o  /0recb|jdtj|jS)zEA dictionary counting the number of attributes referencing an object.r.)rGrObjectIdentityDictionaryr.r&s rc_obj_reference_countszLayer._obj_reference_countsQs.   !=!0!I!I!KM  * **recBt||s|j||yy)aCreate the attribute with the default value if it hasn't been created. This is useful for fields that is used for tracking purpose, _trainable_weights, or _layers. Note that user could create a layer subclass and assign an internal field before invoking the Layer.__init__(), the __setattr__() need to create the tracking fields and __init__() need to not override them. Args: name: String, the name of the attribute. default_value: Object, the default value of the attribute. N)rh __setattr__)r\r^ default_values rcrGzLayer._maybe_create_attributeXs# 4  t]+ rect||d}|j}||vrttj||y||}|dkDr&|dz ||<ttj||y||=ttj||t |tstj|r;ttj|+d|jDcgc] }||us| c}t |tjrwttj|+d|jDcgc] }||us| c}ttj|+d|jDcgc] }||us| c}yycc}wcc}wcc}w)Nrr:r8r9)r;r?superr' AutoTrackable __delattr__ror-r has_weightsrAr:rVariabler8r9)r\r^existing_valuereference_countsreference_countrwrs rcrFzLayer.__delattr__is|T4.N 11-- M ' ':4@ &~6O*91)<~& M ' ':4@  > * - % %t8>>5)  ' ' 7 M ' ': $33 Oq7N1 OQ.,"7"78 M ' ': -- I.1H1 IK M ' ': "11 MQn5L1 MO 9 P J Ns$ E? "E? - F 7F ( F 2F c|dk(s#t|ddrt|j|r ttj ||ytj|||j}|jddz|< |j|ddlm}t!j"D]At%|j&st|ds'|j(j+Ct|d drt%t,st/j0r^|j3d gt5fd |j6Ds.|j6j+td rd_t!j"D]t%t:j<s|j3d g|j3dgj>r;t5fd|j@Drm|j@j+n:t5fd|jBDr|jBj+tEjFttj ||y#t$rtdj|wxYw#t$rY0wxYw)N_self_setattr_trackingTzCan't set the attribute "{}", likely because it conflicts with an existing read-only @property of the object. Please choose a different name.) trackabler8r^rr)rhrNrYr:c3&K|]}|u ywr|rk)rr.r8s rcrz$Layer.__setattr__..sLU%5.L_use_resource_variablesr8r9c3&K|]}|u ywr|rkrrLvals rcrz$Layer.__setattr__..s9Asax9rQc3&K|]}|u ywr|rkrTs rcrz$Layer.__setattr__..s=Asax=rQ)$r;rhrrDr'rErArrr)sticky_attribute_assignmentr?rDrFtensorflow.python.kerasrhr*rroMetricrNrqr-rrGrGrr:rRrrHr]r8r9rr)r\r^r8rJmetrics_modulerUrs ` @rcrAzLayer.__setattr__st (( D2D 9%. m))4$J;> K  K cy)NTrkr&s rc _is_layerzLayer._is_layers rec|jjjjj |d|jj jjj |d|jj jjj |d|j }|d|vxs |j |_n||_d|vxs |j |_y)Nrr) r_call_full_argspecfgetcacherEr_call_accepts_kwargsrr)r\expects_training_argrs rcrTzLayer._init_call_fn_argssNN%%**0044T4@NN  %%++//d;NN'',,2266tTB%%L#$.,$>%>$($=$=  $8d $ 48"77 rec@tj|jSr|)rrrmr&s rcr^zLayer._call_full_argspecs  $ $TYY //recP|jj}|r |ddk(r|ddS|S)Nrr\r)r^r~)r\rs rcrzLayer._call_fn_argss4&&++HHQK6) ab\ Orec^t}t|jD] \}}|||< |Sr|)r enumerater)r\call_fn_arg_positionsposrs rcr#zLayer._call_fn_arg_positions s;!Fd001'S#&C '  rec2|jjduSr|)r^varkwr&s rcrazLayer._call_accepts_kwargs s  " " ( ( 44rec@d|jvxst|ddduS)Nrr)rr;r&s rcrzLayer._should_compute_mask s- d(( ( < D.$ /t ;=recgt}}|D];}t||vs|j||jt|=|S)z;Dedupe weights while maintaining order as much as possible.)ridrqadd)r\r0rseen_idsrLs rc_dedup_weightszLayer._dedup_weights sK35HF  Ah  a RU  Mrec,tj|Sr|)rLayerSavedModelSaverr&s rc_trackable_saved_model_saverz"Layer._trackable_saved_model_saver& s  3 3D 99rec.|jjSr|)rsobject_identifierr&s rc_object_identifierzLayer._object_identifier*   , , > >>rec.|jjSr|)rstracking_metadatar&s rc_tracking_metadatazLayer._tracking_metadata. rwrec |dk(r!|d}|jj|}ni}|jt||fi||S)N savedmodelr`)rstrackable_childrenrzrD_trackable_children)r\ save_typerar`childrenrs rcr~zLayer._trackable_children2 sQL Woe22EEeLhh OOEG/ DVDE Orec^|jj}|jdd|S)NrK)__dict__copyrEr\states rc __getstate__zLayer.__getstate__> s) MM   E IIot$ Lrec`tj|d<tj|d|y)NrKr)rIrJobjectrArs rc __setstate__zLayer.__setstate__G s%&__.E/ tZ/re)TNNFr|)NN)T)F)FF) checkpoint)vr __module__ __qualname____doc__ frozenset itertoolschainr!Module_TF_MODULE_IGNORED_PROPERTIESrO no_automatic_dependency_trackingrdrdefaultrir+for_subclass_implementersrmrtrrAUTOVariableAggregationNONErr classmethodrrrrr#rpropertyr_r^r`do_not_generate_docsr5setterr]r7rrNrSrZrhrprErrrrrrrrrrrrrrr4rrdo_not_doc_inheritablerrrrr$rrrrrrOrr rr rCrrlrrrrrrrrrrr8r<r?rGrFrAr\rTrcached_per_instancer^rr#rarrprsrvrzr~rr __classcell__)rs@rcr-r-Gs<J#,OIOO% mm11-#  --p5.p5d --.$)) * ))*,))!! !"!-!E!E!J!J)==BBd*dL""H"(T))$*$L*@D  - -   C C $$D% D ??     & &--   --.  2  .))t-*t-l   ))A?*A?F))F"*F"PO1b*3X2&1&2&2& 2 2( 2 2(<&=&6$7$ J J$ L L$ ' '>2* 3 3< &&'  && '  &&2'2$&&,',   " " & & % % --&.& & & --'.'"(J  ,  ,F - -  ==11#)J E;"&;P  7<$"H#B E 0 + +  --,., *OXIF\9  ""0# 0  ""#  ""!# !  ""5# 5 ""=# =  : : ? ? ? ? 0rer-ceZdZdZdZy) KerasHistorya~Tracks the Layer call that created a Tensor, for Keras Graph Networks. During construction of Keras Graph Networks, this metadata is added to each Tensor produced as the output of a Layer, starting with an `InputLayer`. This allows Keras to track how each Tensor was produced, and this information is later retraced by the `keras.engine.Network` class to reconstruct the Keras Graph Network. Attributes: layer: The Layer that produced the Tensor. node_index: The specific call to the Layer that produced this Tensor. Layers can be called multiple times in order to share weights. A new node is created every time a Tensor is called. tensor_index: The output index for this Tensor. Always zero if the Layer that produced this Tensor only has one output. Nested structures of Tensors are deterministically assigned an index via `nest.flatten`. rkN)rrrr __slots__rkrercrrM s&)rer)r.r tensor_index)Krrwr\rrIrnumpyr tensorflow.python.autograph.corer tensorflow.python.autograph.implrrtensorflow.python.distributertensorflow.python.eagerrtensorflow.python.frameworkrrr r r r r rrXrrrrtensorflow.python.keras.enginerrr'tensorflow.python.keras.mixed_precisionrrr*tensorflow.python.keras.saving.saved_modelrtensorflow.python.keras.utilsrrrrr+tensorflow.python.keras.utils.generic_utilsr&tensorflow.python.keras.utils.tf_utilsr tensorflow.python.moduler!tensorflow.python.opsr"r#r$rtensorflow.python.ops.raggedr%tensorflow.python.platformr&tensorflow.python.trackabler'r(rOr)tensorflow.python.utilr*tensorflow.tools.docsr+r- namedtuplerrBrkrercrs D3=7+..2+5.93+/005;5EH:J75942EK++*;61597'.C$0J  C$0LHK>BD6  re