6biӋSrSSKrSSKrSSKJs Jr SSKJs Jr SSK J r SSK J r SSKJr SSKJr SSKJr SSKJr \R*"5rS0S jrS0S jrS\ R2SSSS SSS\ R4R6\ R8R:SSS 4S jrS rSr Sr!Sr"Sr#Sr$Sr%S1Sjr&Sr'Sr(Sr)Sr*Sr+Sr,\ RZR]\,5 "SS5r/"SS5r0Sr1S r2S!r3S2S"jr4S#r5Sq6\"S$/S%9S&5r7\"S'/S%9S(5r8S)r9"S*S+5r:S,r;S-rg)3z?Contains private utilities used mainly by the base Layer class.N)backend) dtensor_api)control_flow_util) tf_inspect)tf_utils) keras_exportcRSSKJn URXRS9nX3"U54$)Nr)metrics)namedtype) tf_keras.srcr Meanr )valuer metrics_module metric_objs ^/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/engine/base_layer_utils.pycreate_mean_metricr#s.7$$$kk$BJ z%( ((cUb[U5(dUnSnXE4$[R"U5(aU"5nU(a[R"XXS9nO[R"XUS9nUR nXE4$)N)r layout)r )callablerisclass functoolspartial base_dtype) initializerr shaperinit_valvariable_dtypes rinfer_init_val_and_dtyper ,sx '<'<  ##   k * *%-K  ((%H!((5IH))  ##rTc[X2X5unn[R"U5nUcSnU c,[R"UUUUUUUUU U U U(aUUS9 $SUS9 $[ R "UUUUUUUU U U U(aUS9 $SS9 $)a7Util to create a variable (relies on `variable_scope.variable`). Some reuse-related technicalities prevent us from using `variable_scope.get_variable()` directly, so we use a subcomponent that has fewer constraints (`variable_scope.variable()`). In the longer term, it seems like a similar "default variable creator" method should exist in `Trackable` instead. When this happens, we can get rid of this temporary solution. TODO(fchollet): remove this method when no longer needed. Args: name: Variable name. shape: Variable shape. dtype: The type of the variable. Defaults to `self.dtype` or `float32`. initializer: Initializer 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` becomes `True` unless `synchronization` is set to `ON_READ`. Defaults to `None`. caching_device: Passed to `tf.Variable`. validate_shape: Passed to `tf.Variable`. constraint: Constraint instance (callable). use_resource: Whether to use a `ResourceVariable`. collections: List of graph collections keys. The new variable is added to these collections. Defaults to `[GraphKeys.GLOBAL_VARIABLES]`. 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: Not handled at this time. layout: the optional DTensor layout, used for creating DVariable. Returns: Variable instance. NT) initial_valuer trainablecaching_devicer validate_shape constraint use_resource collectionssynchronization aggregationr$experimental_enable_variable_lifting) r"r r#r$r r%r&r(r)r*r)r tf TensorShapetf1Variabledtensor DVariable)r rr rr#r$r%r&r'r(r)r* partitionerrr+rrvariable_shapes r make_variabler4>s| 8E Hn^^E*N  ~ ||") )!%#+#$2.1U  9=1U    ") )!#+#$2.  9=  rcFSn[RRX5$)zRetrieves the output mask(s) of the previous node. Args: input_tensors: An arbitrary structure of Tensors. Returns: A mask tensor or list of mask tensors. c[USS5$)N _keras_maskgetattr)xs r_collect_previous_mask5collect_previous_mask.._collect_previous_masksq-..rr,nest map_structure) input_tensorsr;s rcollect_previous_maskrAs/ 77 !7 GGrc`[S[RRU555$)Nc3:# UHn[US5v M g7f_keras_historyN)hasattr.0r:s r *have_all_keras_metadata..sN5Mwq*++5Ms)allr,r>flatten)tensorss rhave_all_keras_metadatarNs NRWW__W5MN NNrcR[R"U[R"5S9$)N)rr )r. placeholderrfloatx)rs r generate_placeholders_from_shaperRs ??gnn.> ??rc4[U[5/5upU$)aWraps TensorFlow Operations for compatibility with the Functional API. This method checks to see if a Tensor in `tensors` is missing TF-Keras metadata and has its origin in a TF-Keras `Input` Layer. If so, this method will replace the raw TensorFlow Operations that created this tensor with `TensorFlowOpLayer` instances that create identical operations. Any Tensors not originating from a TF-Keras `Input` Layer will be treated as constants when constructing `TensorFlowOpLayer` instances. Args: tensors: A structure of Tensors, some of which come from raw TensorFlow operations and need to have TF-Keras metadata assigned to them. Returns: created_layers: List. The `TensorFlowOpLayer` instances created to wrap the raw Tensorflow operations. )_create_keras_history_helperset)rM_created_layerss rcreate_keras_historyrXs&5WceRHA rFc [R"5(a [S5eSSKJn [ R RU5n/n/nUGHDn[USS5bM[U[ R[R45(aURUR5 M`[R"U5(aURU5 MURnX;dM[!UR"5n 0n /n [%U 5Hup['U 5(aU RU 5 M([ R(R+5=(a [R"5(+n[,R."[R0"55nU(dU(d [2(aXU 'M[ R4"5 [6R8"/U 5"/5X'SSS5 M [;U 5n [=XU5upUR>nUR@RC5nUREUU US9nURU5 URGU 40URHS9 URKU/5 GMG U(dU(a.Sn[S RMU[OU5[OU5S 95eX4$!,(df  GM=f) aHelper method for `create_keras_history`. Args: tensors: A structure of Tensors for which to create TF-Keras metadata. processed_ops: Set. TensorFlow operations that have already been wrapped in `TensorFlowOpLayer` instances. created_layers: List. The `TensorFlowOpLayer` instances created. Returns: Tuple. First element is the updated set of TensorFlow Operations that have been wrapped in `TensorFlowOpLayer` instances. Second element is a list of the `TensorFlowOpLayer` instances created. zB`create_keras_history` should only be called if eager is disabled!r) base_layerrEN) constantsr )argskwargsoutputsz weights_mult = lambda x: tf.sparse.sparse_dense_matmul(x, weights) output = tf.keras.layers.Lambda(weights_mult)(input) a Tensorflow ops that generate ragged or sparse tensor outputs are currently not supported by TF-Keras automatic op wrapping. Please wrap these ops in a Lambda layer: ``` {example} ``` Sparse ops encountered: {sparse_ops} Ragged tensors encountered: {ragged_tensors} )example sparse_opsragged_tensors)(r.#executing_eagerly_outside_functions ValueErrortf_keras.src.enginerZr,r>rLr9 isinstance SparseTensorSparseTensorValueappendopr is_raggedlistinputs enumerateuses_keras_history distributein_cross_replica_contextrGraphOrParentsInXlaContextget_default_graph_UNSAFE_GRAPH_OP_LAYER_CREATION init_scoperfunctionunnest_if_single_tensorrTr node_defSerializeToStringTensorFlowOpLayer_set_connectivity_metadatar^updateformatstr)rM processed_opsrWrZ tensor_listr`ratensorri op_inputsr[ layer_inputsiop_inputds_with_session using_xlar rwop_layerlambda_examples rrTrTs ..00 P  /''//'*KJN 6+T 2 >  fr0E0EF G G   fii (    f % %  ! !& )  YY "RYYIIL(3 %h// ''1  >>@J # G G II$!2 L L--/!I($:: (0! ]]_+2+;+;B+I"+MIL-_1 443<@L,H^- )M77D{{446H!33ID4H  ! !( +  / /"_R 0   " &op^ = >DV&z?">2>D>    ((C-_s  K K) c[RRU5n[U[5(d[ U5S:XaUSnU$)Nr)r,r>rLredictlen)r@flat_input_tensorss rrvrvJsA7 mT * *s3E/F!/K*1- rc[RRU5n[5R(aU(dg[ SU55(ag[ U5$)aCheck if any Tensors need to be wrapped in TensorFlowOpLayers. This will never return True inside a sublayer, because sublayers do not need to create TF-Keras History. Otherwise, this returns True if one or more of `tensors` originates from a `keras.Input` and does not have `_keras_history` set. Args: tensors: An arbitrary nested structure of Tensors. ignore_call_context: Whether to ignore the check of if currently outside of a `call` context. This is `True` when creating KerasHistory inside `Node`, where we always know that Tensors are being used with the Functional API. Returns: Bool, whether at least one Tensor needs to be wrapped. Fc3@# UHn[USS5SLv M g7frDr8)rHrs rrI&needs_keras_history..js& #F ($/t;#s)r,r>rL call_contextin_callrKrn)rMignore_call_contextr@s rneeds_keras_historyrUsQ$GGOOG,M~&9  #   g &&rc*[5R$)z:Returns if currently executing inside of a TF-Keras graph.)rin_keras_graphrris_in_keras_graphrss > ( ((rcN[R"5=(d [5$)z4Returns if in eager mode or inside of a tf.function.)r,executing_eagerlyis_in_tf_functionrrris_in_eager_or_tf_functionrxs   ! 8%6%88rc [R"5(dg[R"5(dg[ 5(ag[R "5n[ USS5(a!URRS5(agg)z#Returns if inside of a tf.function.Fr wrapped_functionT) r.rbr,inside_functionrrrr9r startswith)graphs rrr}sr  2 2 4 4      ! ! #Eufe$$)>)>** rc[5n[RRU5nU(a/nUHtn[ U5U;aMUR [ U55 [ USS5bM>[ USS5b gURURR5 Mv UnU(aM[U5 g![a Mf=f)aCheck if at least one Tensor originates from a `keras.Input`. This is `True` if at least one Tensor has its origin in a `keras.Input`. Any Tensor that originates from a `keras.Input` will have a dependency Tensor with a `_keras_history` attribute attached. Tensors that have already been checked to not originate from a `keras.Input` are marked as `_keras_history_checked`. Args: tensors: An arbitrary nested structure of Tensors. Returns: Bool, whether at least one Tensor originates from a `keras.Input`. _keras_history_checkedNrETF) rUr,r>rLidaddr9extendrirlAttributeError mark_checked)rMchecked_tensorstensors_to_checknew_tensors_to_checkrs rrnrnseOwww/ !&F&z_,   6 +v7>Jv/6B $++FII,<,<='"0'  . "  s%C CCcHSn[RRX5 g)zMarks that these Tensors should not be tracked. This prevents Layers from attempting to create TensorFlowOpLayers for these Tensors. Args: tensors: An arbitrary structure of Tensors. cSUlg)NT)r)rs r _mark_checked#mark_checked.._mark_checkeds (,%rNr=)rMrs rrrs-GG-1rcX[[SS5nUc[5nU[lU$)z'Returns currently active `CallContext`.rN)r9 _call_context CallContextr)call_ctxs rrrs*}nd;H=%- " Orc\rSrSrSrSrSSjr\S5r\S5r \S5r \S 5r \S 5r \S 5r \S 5rS rg)riaJKeeps track of properties currently inside a Layer/Model's `call`. Attributes: in_call: Whether currently inside the `call` of a Layer. layer: The `Layer` whose `call` is currently active. inputs: The inputs to the currently active `Layer`. build_graph: Whether currently inside a Graph or FuncGraph. training: Whether currently executing in training or inference mode. saving: Whether currently saving to SavedModel. frozen: Whether currently executing inside a `Layer` with `trainable` set to `False`. in_keras_graph: Whether executing inside the TF-Keras Graph. c:SUlSSSSSS.UlSUlg)NFlayerrl build_graphtrainingsaving)r_state_in_keras_graphselfs r__init__CallContext.__init__s-      %rNc(UUUUUS.n[X5$)aPush a Layer and its inputs and state onto the current call context. Args: layer: The `Layer` whose `call` is currently active. inputs: The inputs to the currently active `Layer`. build_graph: Whether currently inside a Graph or FuncGraph. training: Whether currently executing in training or inference mode. saving: Whether currently saving to SavedModel. Returns: Context manager. r)CallContextManager)rrrlrrrstates renterCallContext.enters'&   "$..rc URS$)Nrrrs rrCallContext.layers{{7##rc URS$)Nrlrrs rrlCallContext.inputs{{8$$rc URS$Nrrrs rrCallContext.build_graphs{{=))rc URS$)Nrrrs rrCallContext.trainings{{:&&rc URS$)Nrrrs rrCallContext.savingrrcRURSnU(dgUR(+$)NrF)rr#)rrs rfrozenCallContext.frozen#s# G$??""rc[R"5(agUR=(d# [[R "5SS5S:H$)NFr keras_graph)r,rrr9r get_graphrs rrCallContext.in_keras_graph*sD    ! !   Kw((*FD9]J r)rrrN)__name__ __module__ __qualname____firstlineno____doc__rrpropertyrrlrrrrr__static_attributes__rrrrrs  %/,$$%%**''%%##   rrc*\rSrSrSrSrSrSrSrg)ri6z"Context manager for `CallContext`.c0XlX lUSUlgr) _call_ctxr _build_graph)rrrs rrCallContextManager.__init__9s! !-0rcLURnURUlURUlSUlURUlUR (aMUR UlUR =(d# [[R"5SS5S:HUlgg)NTr r) rr _prev_in_callr _prev_staterr_prev_in_keras_graphr9rr)rrs r __enter__CallContextManager.__enter__>s>>%--#??++   (0(@(@D %((O7,,.=N  $ rcURnURUlURUlUR (aUR Ulggr)rrrrrrrr)rexc_infors r__exit__CallContextManager.__exit__OsB>>--**   '+'@'@H $ r)rrrrrrN) rrrrrrrrrrrrrr6s,1 "Arrc[[URSSU55nURU5 SU;=(a USSL$)zDReturns whether a user passed the `training` argument in `__call__`.Nr)rzipr\r{)argspecr\r] full_argss rtraining_arg_passed_to_callrXsHSab)401I V  " Hy'Checks that tensors passed to `add_*` method match the TF-Keras graph. When one of the `add_*` method is called inside a V2 conditional branch, the underlying tensor gets created in a FuncGraph managed by control_flow_v2. We need to raise clear error messages in such cases. Args: tensor: Tensor to check, or `False` if it is known that an error should be raised. method: Caller method, one of {'add_metric', 'add_loss', 'add_update'}. force_raise: If an error should be raised regardless of `tensor`. Raises: RuntimeError: In case of an out-of-graph tensor. ractivity_regularizerag class TestModel(tf.keras.Model): def __init__(self): super(TestModel, self).__init__(name='test_model') self.dense = tf.keras.layers.Dense(2, activity_regularizer='l2') def call(self, x, training=None): if training: return self.dense(x) else: return self.dense(x) a class TestModel(tf.keras.Model): def __init__(self): super(TestModel, self).__init__(name='test_model') self.dense = tf.keras.layers.Dense(2, activity_regularizer='l2') def call(self, x, training=None): return self.dense(x) zRYou are using a layer with `activity_regularizer` in a control flow branch, e.g.: z This is currently not supported. Please move your call to the layer with `activity_regularizer` out of the control flow branch, e.g.: aC You can also resolve this by marking your outer model/layer dynamic (eager-only) by passing `dynamic=True` to the layer constructor. Any kind of control flow is supported with dynamic layers. Note that using `dynamic=True` requires you to implement static shape inference in the `compute_output_shape(input_shape)` method. add_metricz def call(self, inputs, training=None): if training: metric = compute_metric(inputs) self.add_metric(metric, name='my_metric', aggregation='mean') return inputs z def call(self, inputs, training=None): if training: metric = compute_metric(inputs) else: metric = 0. self.add_metric(metric, name='my_metric', aggregation='mean') return inputs add_lossz def call(self, inputs, training=None): if training: loss = compute_loss(inputs) self.add_loss(loss) return inputs z def call(self, inputs, training=None): if training: loss = compute_loss(inputs) else: loss = 0. self.add_loss(loss) return inputs z def call(self, inputs, training=None): if training: self.add_update(self.w.assign_add(1)) return inputs z def call(self, inputs, training=None): if training: increment = 1 else: increment = 0 self.add_update(self.w.assign_add(increment)) return inputs aYou are using the method `{method}` in a control flow branch in your layer, e.g.: {bad_example} This is not currently supported. Please move your call to {method} out of the control flow branch, e.g.: {correct_example} You can also resolve this by marking your layer as dynamic (eager-only) by passing `dynamic=True` to the layer constructor. Any kind of control flow is supported with dynamic layers. Note that using `dynamic=True` requires you to implement static shape inference in the `compute_output_shape(input_shape)` method.)method bad_examplecorrect_exampleN)r.rbrFris_control_flow_graph RuntimeErrorr|)rr force_raiserrs rcheck_graph_consistencyros  //11 FG $ $ LL . . + +  K  O//:m<**+    \ ! K Oz ! K O K  O ABH' /BHB  u / % 2rcN^U4Sjn[RRX 5$)z@Marks `outputs` as the return values for automatic control deps.c>[R"U5(dU$TRU5n[USS5b!TRUR5UlOSUl[USS5bUR UlU$)z>Marks `tensor` as the return value for automatic control deps.r7N_tfp_distribution)r, is_tensormark_as_returnr9r7r )r return_tensoracds r_mark_as_return'mark_as_return.._mark_as_returns}||F##M**62 6=$ / ;(+(:(:6;M;M(NM %(,M % 6. 5 A.4.F.FM +rr=)r^rrs ` rr r s$ 77  ::rz%keras.layers.enable_v2_dtype_behavior)v1cSqg)a0Enable the V2 dtype behavior for TF-Keras layers. By default, the V2 dtype behavior is enabled in TensorFlow 2, so this function is only useful if `tf.compat.v1.disable_v2_behavior` has been called. Since mixed precision requires V2 dtype behavior to be enabled, this function allows you to use mixed precision in TF-Keras layers if `disable_v2_behavior` has been called. When enabled, the dtype of TF-Keras layers defaults to floatx (which is typically float32) instead of None. In addition, layers will automatically cast floating-point inputs to the layer's dtype. >>> x = tf.ones((4, 4, 4, 4), dtype='float64') >>> layer = tf.keras.layers.Conv2D(filters=4, kernel_size=2) >>> print(layer.dtype) # float32 since V2 dtype behavior is enabled float32 >>> y = layer(x) # Layer casts inputs since V2 dtype behavior is enabled >>> print(y.dtype.name) float32 A layer author can opt-out their layer from the automatic input casting by passing `autocast=False` to the base Layer's constructor. This disables the autocasting part of the V2 behavior for that layer, but not the defaulting to floatx part of the V2 behavior. When a global `tf.keras.mixed_precision.Policy` is set, a TF-Keras layer's dtype will default to the global policy instead of floatx. Layers will automatically cast inputs to the policy's compute_dtype. TNV2_DTYPE_BEHAVIORrrrenable_v2_dtype_behaviorr s @rz&keras.layers.disable_v2_dtype_behaviorcSqg)zoDisables the V2 dtype behavior for TF-Keras layers. See `tf.compat.v1.keras.layers.enable_v2_dtype_behavior`. FNrrrrdisable_v2_dtype_behaviorr.s rcl[c([RRR 5$[$)z1Returns True if the V2 dtype behavior is enabled.)rr, __internal__tf2enabledrrrv2_dtype_behavior_enabledr8s' ""**,, rc@\rSrSrSrSr\S5rSrSr Sr Sr g ) TrackableWeightHandleri?aqKeras wrapper for handling Trackable object saving and restoring. This class handles Trackables in both V1 and V2 modes, ensuring that they can be saved and restored with the correct data and without adding additional ops on every save. Attributes: trackable: The trackable to wrap. num_tensors: The number of tensors that this trackable requires for saving. c^[U[RRR5(d[ US35eUTl[RR5Tl [RRRU5R5nU(dSTl STl STlg[U5S:XGaZ[!U5Sn["R$"5(aFUTl[TR'5R(5Tl U4SjTl U4SjTlg/TlU"5Tl[TR&R(5Tl TR&R(HSnUR,nTR*R/["R0"UR2UR455 MU TR&R7TR*S5TlTR:Tl U4SjTlg[ S US [U5S 35e) Nz is not a Trackable object.rcgrr)weightss r1TrackableWeightHandler.__init__..Ys4rc/$rrrrrr"r#Zs2rrcD>TR5RUS5$r) _saveablerestore)r!rs rr"r#gst~~/?/G/GT0rcv>TR5RVs/sHoRPM sn$s snfrr&specsrspecrs rr"r#js/,0NN,<,B,B(,BDKK,B((s6cn>TRRVs/sHoRPM sn$s snfrr)r+s rr"r#~s,,0NN,@,@(,@DKK,@((s2z?Only Trackables with one Saveable are supported. The Trackable z has z Saveables.)rer,rtracking Trackablerc _trackablero get_strategy_distribute_strategysaveable_objects_from_trackablevalues _num_tensors_setter_getterrrkr.rbr&r*_placeholder_tensorsrrhrPr rr' _assign_op_set_weights_v1)r trackable saveablessaveabler,rs` rrTrackableWeightHandler.__init__Ls)R__%=%=%G%GHH {*EFG G#$&MM$>$>$@!OO,,LL  &(   !D /DL%DL ^q Iq)H6688 "*$'(8(>(>$?!    -/)!)$'(<(<$=! NN00D![[F--44 fllC1 #'.."8"8--t# $33   !!* 5Y0@ M rcUR$r)r5rs r num_tensors"TrackableWeightHandler.num_tensorss   rc [U5UR:wa2[SURSURS[U5S35eUR U5 g)NzWeight handler for trackable z3 received an incorrect number of weights: expected z weights, got z weights.)rr5rcr0r6)rr!s r set_weights"TrackableWeightHandler.set_weightssb w<4,, ,//@A --./7|nI/  Wrc"UR5$r)r7rs r get_tensors"TrackableWeightHandler.get_tensorss||~rc0n[U5Hup4XBURU'M [R"5R UR U5 gr)rmr8r get_sessionrunr9)rr! feed_dictidxrs rr:&TrackableWeightHandler._set_weights_v1sH $W-KC8>d//4 5.!!$//9=r)r9r2r7r5r8r&r6r0N) rrrrrrrr@rCrFr:rrrrrr?s0 9v!!>rrc[RRU5n[SU55(a[ SUSUS35eg)Nc3V# UHn[U[R5v M! g7fr)rer, RaggedTensorrGs rrI$no_ragged_support..s >:a:a ) ):s')zLayer z; does not support RaggedTensors as input. Inputs received: z@. You can try converting your input to a dense (uniform) tensor.)r,r>rLanyrc)rl layer_name input_lists rno_ragged_supportrUsR(J >: >>>ZL! &x(1 1  ?rcURRVs1sHoRiM snRSS15(+$s snf)zBReturns True if `v` is a PartitionedVariable or a ShardedVariable.PartitionedVariableShardedVariable) __class____mro__r isdisjoint)vclzs ris_split_variabler^sC() (;(;<(; (;<GG  12 rvsF""!! 70)':! )$(  **..33&&++ )-g T H O@B#(c)L'<) 9 &*Z 2 ..|<X X vAADI4 ~ B;09:;<D:;<=]>]>@  ?r