6biBSrSSKrSSKrSSKrSSKrSSKJs Jr SSK J r SSK J r SSK Jr SSKJr SSKJr SSKJr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr \"S5"SS\R@\RBS95r""SS\"5r#\"S5"SS\#55r$\"S5"SS\#55r%\"S5"SS\%55r&\"S5"S S!\"55r'"S"S#\#5r("S$S%\(5r)S&r*S'r+S(r,"S)S*\-5r.g)+zBase Metric classes.N)backend) dtensor_api)utils) base_layer)base_layer_utils) keras_tensor)metric_serialization) generic_utils) losses_utils) metrics_utils)tf_utils) keras_export) doc_controlszkeras.metrics.Metricc^\rSrSrSrSU4SjjrU4SjrSrSrSSjr \ S 5r S r S r \RS 5rS r\RS5r\R(S\R,R.\R0R2SS4U4Sjj5r\ S5r\ S5r\ S5r\R>\R@S55r!Sr"U=r#$)Metric)aEncapsulates metric logic and state. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. **kwargs: Additional layer keywords arguments. Standalone usage: ```python m = SomeMetric(...) for input in ...: m.update_state(input) print('Final result: ', m.result().numpy()) ``` Usage with `compile()` API: ```python model = tf.keras.Sequential() model.add(tf.keras.layers.Dense(64, activation='relu')) model.add(tf.keras.layers.Dense(64, activation='relu')) model.add(tf.keras.layers.Dense(10, activation='softmax')) model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()]) data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10) ``` To be implemented by subclasses: * `__init__()`: All state variables should be created in this method by calling `self.add_weight()` like: `self.var = self.add_weight(...)` * `update_state()`: Has all updates to the state variables like: self.var.assign_add(...). * `result()`: Computes and returns a scalar value or a dict of scalar values for the metric from the state variables. Example subclass implementation: ```python class BinaryTruePositives(tf.keras.metrics.Metric): def __init__(self, name='binary_true_positives', **kwargs): super(BinaryTruePositives, self).__init__(name=name, **kwargs) self.true_positives = self.add_weight(name='tp', initializer='zeros') def update_state(self, y_true, y_pred, sample_weight=None): y_true = tf.cast(y_true, tf.bool) y_pred = tf.cast(y_pred, tf.bool) values = tf.logical_and(tf.equal(y_true, True), tf.equal(y_pred, True)) values = tf.cast(values, self.dtype) if sample_weight is not None: sample_weight = tf.cast(sample_weight, self.dtype) sample_weight = tf.broadcast_to(sample_weight, values.shape) values = tf.multiply(values, sample_weight) self.true_positives.assign_add(tf.reduce_sum(values)) def result(self): return self.true_positives ``` Nc >[TU]"SXS.UD6 SUlSUl[R "5(d>Uc[ R"5O[R"U5RUl gg)NnamedtypeT) super__init__statefulbuiltrv2_dtype_behavior_enabledrfloatxtfas_dtyper_dtype)selfrrkwargs __class__s Z/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/metrics/base_metric.pyrMetric.__init__rsb :d:6:  99;;%*M r{{57I7N7N K<cd>^^[[U] U5n[R"5(d[ U5(aUR mU4SjnOj[UR [RRR5(a UR nO [R"UR 5n[R"[R"U5U5UlUR mU4Sjn[R"[R""U5U5UlU$)Nc>[RRR5n[RRR TU5nU"U0UD6$Nr __internal__ autographcontrol_status_ctx tf_convert)argsr"control_statusag_update_stateobj_update_states r$update_state_fn'Metric.__new__..update_state_fnsL!#!:!:!M!M!O"$//";";"F"F$n#'777r&c>[RRR5n[RRR TU5nU"U0UD6$r)r*)r/r"r0 ag_result obj_results r$ result_fn!Metric.__new__..result_fnsL__66IIKN11<<NId-f- -r&)rr__new__ris_in_eager_or_tf_function is_built_in update_state isinstancerr+functionFunctiontypes MethodTyper update_state_wrapperresultresult_wrapper) clsr/r"objr3r8r7r2r#s @@r$r:Metric.__new__}sFC(-  6 6 8 8K.>"? ++  . . ? ZZ  .%%  ( ( 3S   r&cH^U4SjnSSKJn UR"U/UQ70UD6$)zAccumulates statistics and then computes metric result value. Args: *args: **kwargs: A mini-batch of inputs to the Metric, passed on to `update_state()`. Returns: The metric value tensor. c>[S[RRX4555(aSnOTR"U0UD6n/nUbUR U5 [R "U5 TR5n[U[5(a [S0UD6nTUl UsSSS5 $!,(df  g=f)z;Updates the state of the metric in a replica-local context.c3V# UHn[U[R5v M! g7fr))r>r KerasTensor).0args r$ .replica_local_fn..s':C3 8 899:s')Nr) anyrnestflattenr=appendcontrol_dependenciesrDr>dict _MetricDict _metric_obj)r/r" update_op update_opsresult_tr!s r$replica_local_fn)Metric.__call__..replica_local_fns77??D>:!  --t>v> J$!!),((4;;= h--*6X6H(,$'544s 89B;; C r)distributed_training_utils)tf_keras.src.distributer^call_replica_local_fn)r!r/r"r\r^s` r$__call__Metric.__call__s6 B *??  # '-  r&cSRSUR5R555nURRSUS3$)N,c34# UHupUSU3v M g7f)=Nr)rMkvs r$rO!Metric.__str__..sI/Htq1#Qqc /Hs())join get_configitemsr#__name__)r!r/s r$__str__Metric.__str__sDxxIt/@/F/F/HII..))*!D633r&cURUR55nUR(aUR UR 55 X!U'U$![an[SUS35eSnAff=f)NzCalling `__deepcopy__()` on a TF-Keras metric requires the metric to be serializable, i.e. it should implement `get_config()`. Error encountered during serialization: []) from_configrmNotImplementedErrorweights set_weights get_weights)r!memonew_selfes r$ __deepcopy__Metric.__deepcopy__s} ''(9:H <<  !1!1!3 4T # %<=>3aA  sA A5!A00A5cUR$r))r r!s r$r Metric.dtypes {{r&c4URURS.$)z.Returns the serializable config of the metric.rrrs r$rmMetric.get_configs DJJ77r&c8[R"UR5(d>[R"SUR R <S3SS9 UR5$[R"URVs/sHoS4PM sn5 gs snf)zResets all of the metric state variables. This function is called between epochs/steps, when a metric is evaluated during training. Metric z implements a `reset_states()` method; rename it to `reset_state()` (without the final "s"). The name `reset_states()` has been deprecated to improve API consistency.) stacklevelrN) r is_default reset_stateswarningswarnr#rorbatch_set_value variablesr!rhs r$ reset_stateMetric.reset_statesw ''(9(9:: MM#'.."9"9<  $$& &  # #T^^$D^V^$D E$Ds Bc[S5e)aaAccumulates statistics for the metric. Note: This function is executed as a graph function in graph mode. This means: a) Operations on the same resource are executed in textual order. This should make it easier to do things like add the updated value of a variable to another, for example. b) You don't need to worry about collecting the update ops to execute. All update ops added to the graph by this function will be executed. As a result, code should generally work the same way with graph or eager execution. Args: *args: **kwargs: A mini-batch of inputs to the Metric. "Must be implemented in subclasses.ru)r!r/r"s r$r=Metric.update_state s&""FGGr&c(/nUHn[UR5[UR5:wa[SUSU35e[URUR5H%upEUR UR U55 M' M U$)aMerges the state from one or more metrics. This method can be used by distributed systems to merge the state computed by different metric instances. Typically the state will be stored in the form of the metric's weights. For example, a tf.keras.metrics.Mean metric contains a list of two weight values: a total and a count. If there were two instances of a tf.keras.metrics.Accuracy that each independently aggregated partial state for an overall accuracy calculation, these two metric's states could be combined as follows: >>> m1 = tf.keras.metrics.Accuracy() >>> _ = m1.update_state([[1], [2]], [[0], [2]]) >>> m2 = tf.keras.metrics.Accuracy() >>> _ = m2.update_state([[3], [4]], [[3], [4]]) >>> m2.merge_state([m1]) >>> m2.result().numpy() 0.75 Args: metrics: an iterable of metrics. The metrics must have compatible state. Raises: ValueError: If the provided iterable does not contain metrics matching the metric's required specifications. rz is not compatible with )lenrv ValueErrorziprT assign_add)r!metricsassign_add_opsmetricweight weight_to_adds r$ merge_stateMetric.merge_state s<F4<< C$77 fX%=dVD*-T\\6>>)J%%%f&7&7 &FG*K r&c[S5e)zComputes and returns the scalar metric value tensor or a dict of scalars. Result computation is an idempotent operation that simply calculates the metric value using the state variables. Returns: A scalar tensor, or a dictionary of scalar tensors. rrrs r$rD Metric.resultHs""FGGr&rc >[RR5(a[RR5nOSn0n[R "U5(a[R Rn[USS5bJS[RRUR[R"U5R50n[R "5(a S Sjn XS'[R""US9 [$T U]L"S UUUc UR(OUSU/UUS.UD6sSSS5 $!,(df  g=f) z0Adds state variable. Only for use by subclasses.N_meshlayoutc"XU5upESS/nUHnURUS5 M SUS'[R"SUUUS.UD6$)N use_resource collectionsF$experimental_enable_variable_lifting) initial_valuershaper)rinfer_init_val_and_dtypepoprVariable) initializerrrr"init_val var_dtype v1_only_argsv1_args r$local_v2_var_creator/Metric.add_weight..local_v2_var_creatorzst'7&O&O'#!/ > *FJJvt,+AF=>{{"*# r&getter)layerF)rrr trainablerrsynchronization aggregation)NNNr)r distribute has_strategy get_strategyris_tpu_strategyVariableSynchronizationON_WRITEgetattrdtensorLayout replicatedr TensorShaperankr in_local_vars_contextmaybe_init_scoper add_weightr ) r!rrrrrrstrategyadditional_kwargsrr#s r$rMetric.add_weightVs == % % ' '}}113HH  " "8 , , 88AAO 4$ ' 3'..33JJu 5 : :!   ) ) + +59 "+?h '  & &T 27% %*]dkk' /' $ 3 2 2s (D?? E cUR(a>URnURHnXR- nM UR U5$/$r))r_trainable_weights_metricstrainable_weights_dedup_weights)r!rms r$rMetric.trainable_weightssK >> $ 7 7 ]]!%8%88!#&&'89 9Ir&cUR(a.URnURHnXR- nM O:URUR-nURHnXR - nM UR U5$r))r_non_trainable_weightsrnon_trainable_weightsrrvr)r!rrs r$rMetric.non_trainable_weightss~ >>$($?$? !]]%)@)@@%#++d.E.EE "]]%2%#""#899r&c.[R"U5$r))r MetricSavedModelSaverrs r$_trackable_saved_model_saver#Metric._trackable_saved_model_savers#99$??r&c"UR5$r))rrs r$rMetric.reset_statess !!r&)r rrNNr))$ro __module__ __qualname____firstlineno____doc__rr:rarpr|propertyrrmrabcabstractmethodr=rrDrfor_subclass_implementersrVariableAggregationSUMrON_READrrrrr defaultdo_not_generate_docsr__static_attributes__ __classcell__r#s@r$rr)s.EN (T3 j4"8F$ HH(&P  H H++**..22::A,AJ : :@@&&"'"r&r) metaclassc@^\rSrSrSrSU4SjjrSSjrSrSrU=r $)ReduceizEncapsulates metrics that perform a reduce operation on the values. Args: reduction: a `tf.keras.metrics.Reduction` enum value. name: string name of the metric instance. dtype: (Optional) data type of the metric result. c>[TU]X#S9 XlURSSS9UlU[ R R[ R R4;aURSSS9Ul gg)Nrtotalzeros)rcount) rr reductionrrr ReductionSUM_OVER_BATCH_SIZE WEIGHTED_MEANr)r!rrrr#s r$rReduce.__init__sr d0"__W'_B   # # 7 7  # # 1 1  gFDJ  r&c [R"U/U5uunn[R"XR5nUbx[R"X R5n[R"XS9unnn[RRRX!5n[R0"X5n[R("U5n[R2"U/5 UR4R7U5nSSS5 UR"[R$R&:XaW$UR"[R$R8:Xa6[R"[R:"U5UR5n OUR"[R$R<:XaPUc6[R"[R:"U5UR5n O0[R("U5n O[?SUR"S35e[R2"W/5 UR@R7U 5sSSS5 $![ [ 4a, SUS3n[U[5(aUS- n[U5ef=f![ a [R "U5n[R "U5nUR"[R$R&:Xa*[R("U[+[-Xe55S9nGN[R."U[+[-Xe55S9nGNf=f!,(df  GNY=f!,(df  g=f) zAccumulates statistics for computing the metric. Args: values: Per-example value. sample_weight: Optional weighting of each example. Defaults to `1`. Returns: Update op. zGThe output of a metric function can only be a single Tensor. Received: z. z?To return a dict of values, implement a custom Metric subclass.N sample_weightaxis Reduction "M" not implemented. Expected "sum", "weighted_mean", or "sum_over_batch_size".)!r ,ragged_assert_compatible_and_get_flat_valuesrcastr r TypeErrorr>rV RuntimeErrorr squeeze_or_expand_dimensionsr+opsbroadcast_weightsrndimrrr reduce_sumlistrange reduce_meanmultiplyrUrrrsizerrur) r!valuesrmsg_r weight_ndim value_sumupdate_total_op num_valuess r$r=Reduce.update_states)UU Hm     $WWV[[1F  $GGM;;?M 99    " 3 3 E E!! [[7FMM&)  $ $i[ 1"jj33I>O2 >>]4488 8" " >>]44HH H$++>J ^^}66DD D$WWRWWV_dkkB ]]=9 %dnn-.DD   $ $o%6 7::((48 7}I& $#HB( &$'' s# # $4 ||F+%ll=9 >>]%<%<%@%@@]]T% *B%CF ^^T% *B%CF 2 1*8 7s< I ;)J'M;M' >]4488 8;;tzz* * ^^  # # 1 1  # # 7 7  77((TZZ@ @%dnn-.DD r&)rrrr)) rorrrrrr=rDrrrs@r$rrsGP5d  r&rzkeras.metrics.SumcN^\rSrSrSr\R SU4Sjj5rSrU=r $)Sumi6a Computes the (weighted) sum of the given values. For example, if values is [1, 3, 5, 7] then the sum is 16. If the weights were specified as [1, 1, 0, 0] then the sum would be 4. This metric creates one variable, `total`, that is used to compute the sum of `values`. This is ultimately returned as `sum`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Sum() >>> m.update_state([1, 3, 5, 7]) >>> m.result().numpy() 16.0 Usage with `compile()` API: ```python model.add_metric(tf.keras.metrics.Sum(name='sum_1')(outputs)) model.compile(optimizer='sgd', loss='mse') ``` cR>[TU][RRXS9 gN)rrr)rrr rrr!rrr#s r$r Sum.__init__Vs& #--11  r&r)sumN rorrrr dtensor_utils inject_meshrrrrs@r$rr6s"<  r&rzkeras.metrics.MeancN^\rSrSrSr\R SU4Sjj5rSrU=r $)Meani]aComputes the (weighted) mean of the given values. For example, if values is [1, 3, 5, 7] then the mean is 4. If the weights were specified as [1, 1, 0, 0] then the mean would be 2. This metric creates two variables, `total` and `count` that are used to compute the average of `values`. This average is ultimately returned as `mean` which is an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Mean() >>> m.update_state([1, 3, 5, 7]) >>> m.result().numpy() 4.0 >>> m.reset_state() >>> m.update_state([1, 3, 5, 7], sample_weight=[1, 1, 0, 0]) >>> m.result().numpy() 2.0 Usage with `compile()` API: ```python model.add_metric(tf.keras.metrics.Mean(name='mean_1')(outputs)) model.compile(optimizer='sgd', loss='mse') ``` cT>[TU][RRUUS9 gr)rrr rrr s r$r Mean.__init__s* #--;;  r&r)meanNr#rs@r$r'r']s#"H  r&r'zkeras.metrics.MeanMetricWrapperc^\rSrSrSr\R SU4Sjj5rS U4SjjrU4Sjr \ U4Sj5r Sr U=r $) MeanMetricWrapperia-Wraps a stateless metric function with the Mean metric. You could use this class to quickly build a mean metric from a function. The function needs to have the signature `fn(y_true, y_pred)` and return a per-sample loss array. `MeanMetricWrapper.result()` will return the average metric value across all samples seen so far. For example: ```python def accuracy(y_true, y_pred): return tf.cast(tf.math.equal(y_true, y_pred), tf.float32) accuracy_metric = tf.keras.metrics.MeanMetricWrapper(fn=accuracy) keras_model.compile(..., metrics=accuracy_metric) ``` Args: fn: The metric function to wrap, with signature `fn(y_true, y_pred, **kwargs)`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. **kwargs: Keyword arguments to pass on to `fn`. c 8>[TU]X#S9 XlX@lg)Nrrr_fn _fn_kwargsr!fnrrr"r#s r$rMeanMetricWrapper.__init__s d0 r&cR>[R"XR5n[R"X R5n[R"X/U5uunnn[ R "X!5up![RRRUR[RRR55nU"X40URD6n[ R"U5n[ R"XSX`R5n[ TU]EXSS9$)aAccumulates metric statistics. `y_true` and `y_pred` should have the same shape. Args: y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`. y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`. sample_weight: Optional `sample_weight` acts as a coefficient for the metric. If a scalar is provided, then the metric is simply scaled by the given value. If `sample_weight` is a tensor of size `[batch_size]`, then the metric for each sample of the batch is rescaled by the corresponding element in the `sample_weight` vector. If the shape of `sample_weight` is `[batch_size, d0, .. dN-1]` (or can be broadcasted to this shape), then each metric element of `y_pred` is scaled by the corresponding value of `sample_weight`. (Note on `dN-1`: all metric functions reduce by 1 dimension, usually the last axis (-1)). Returns: Update op. r)rrr r rr rr+r,r.r/r-r0get_maskapply_valid_maskrrr=r!y_truey_predrag_fnmatchesmaskr#s r$r=MeanMetricWrapper.update_states,--)UU  m     &BB  ))44 HHboo//BBD :$//:$$W-$55 D.. w#G#IIr&c>URR5VVs0sH9upU[R"U5(a[R "U5OU_M; nnn[ U5[LaURUS'[TU])5n[[UR55[UR55-5$s snnf)Nr2) r0rnr is_tensor_or_variablerevaltyper,r/rrmrVr r!rgrhconfig base_configr#s r$rmMeanMetricWrapper.get_configs--/ / ("@"@"C"Cw||A J/  :* * 88F4Lg(* D**,-V\\^0DDEE sAC c>SSKJn URSS5nU[LaU"U"U540UD6$[[U]U5$)Nr)getr2)tf_keras.src.metricsrGrr,rrt)rFrCrGr2r#s r$rtMeanMetricWrapper.from_configsH,ZZd # # #s2w)&) )&8@@r&r/r0rr))rorrrrr$r%rr=rm classmethodrtrrrs@r$r,r,sE4!! *JX FAAr&r,zkeras.metrics.MeanTensorc^\rSrSrSr\R S U4Sjj5rSr\ S5r \ S5r S Sjr Sr S rS rU=r$) MeanTensoriaComputes the element-wise (weighted) mean of the given tensors. `MeanTensor` returns a tensor with the same shape of the input tensors. The mean value is updated by keeping local variables `total` and `count`. The `total` tracks the sum of the weighted values, and `count` stores the sum of the weighted counts. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. shape: (Optional) A list of integers, a tuple of integers, or a 1-D Tensor of type int32. If not specified, the shape is inferred from the values at the first call of update_state. Standalone usage: >>> m = tf.keras.metrics.MeanTensor() >>> m.update_state([0, 1, 2, 3]) >>> m.update_state([4, 5, 6, 7]) >>> m.result().numpy() array([2., 3., 4., 5.], dtype=float32) >>> m.update_state([12, 10, 8, 6], sample_weight= [0, 0.2, 0.5, 1]) >>> m.result().numpy() array([2. , 3.6363635, 4.8 , 5.3333335], dtype=float32) >>> m = tf.keras.metrics.MeanTensor(dtype=tf.float64, shape=(1, 4)) >>> m.result().numpy() array([[0., 0., 0., 0.]]) >>> m.update_state([[0, 1, 2, 3]]) >>> m.update_state([[4, 5, 6, 7]]) >>> m.result().numpy() array([[2., 3., 4., 5.]]) c>[TU]XS9 SUlSUlSUlSUlUbUR U5 gg)NrF)rr_shape_total_count_built_build)r!rrrr#s r$rMeanTensor.__init__sF d0      KK  r&c[R"U5UlURUlUR SUSS9UlUR SUSS9Ul[R"5 [R"5(d)[R"[R"55 SSS5 SUl g!,(df  N=f)Nrr)rrrrT) rrrO_build_input_shaperrPrQ init_scopeexecuting_eagerlyr_initialize_variables _get_sessionrR)r!rs r$rSMeanTensor._build#snnU+ "&++oo7&  oo7&  ]]_''))--g.B.B.DE _s .AC Cc@UR(a UR$S$r))rRrPrs r$rMeanTensor.total2"kkt{{3t3r&c@UR(a UR$S$r))rRrQrs r$rMeanTensor.count6r^r&c [R"XR5nUR(dUR UR 5 O@UR UR :wa&[SUR SUR S35e[R"U5nUb[R"X R5n[R"XS9unnn[RRRX!5n[R&"X25n[R&"X5nUR(R+U5n[R,"U/5 UR.R+U5sSSS5 $![aV [R"U5n[R"U5n[R "U[#[%Xe55S9nNf=f!,(df  g=f)zAccumulates statistics for computing the element-wise mean. Args: values: Per-example value. sample_weight: Optional weighting of each example. Defaults to `1`. Returns: Update op. zeMeanTensor input values must always have the same shape. Expected shape (set during the first call): z. Got: .Nrr)rrr rRrSrrOr ones_liker rr+rrrrr r r r rPrrUrQ)r!rrrrrrrs r$r=MeanTensor.update_state:s-{{ KK % \\T[[ (F;;-  ~Q( \\&)  $GGM;;?M99    " 3 3 E E!! Z?J[[7F++008  $ $o%6 7;;))*58 7 ||F+%ll=9 eK&>!?  8 7s )F 'G/ AG,+G,/ G=cUR(d [S5e[RR UR UR 5$)NzMeanTensor does not have any value yet. Please call the MeanTensor instance or use `.update_state(value)` before retrieving the result.)rRrrrrrrrs r$rDMeanTensor.resultos<{{0  ww$$TZZ<>J>aRXXaggoo/01>J  Js9A2)rVrRrQrOrP) mean_tensorNNr))rorrrrr$r%rrSrrrr=rDrrrrs@r$rMrMse!F 444436j=r&rMc0^\rSrSrSrSU4SjjrSrU=r$)SumOverBatchSizeiaComputes the weighted sum over batch size of the given values. For example, if values is [1, 3, 5, 7] then the metric value is 4. If the weights were specified as [1, 1, 0, 0] then the value would be 1. This metric creates two variables, `total` and `count` that are used to compute the average of `values`. This average is ultimately returned as sum over batch size which is an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. cT>[TU][RRUUS9 gr)rrr rrr s r$rSumOverBatchSize.__init__s* #--AA  r&r)sum_over_batch_sizeNrorrrrrrrrs@r$rmrms   r&rmcL^\rSrSrSrSU4SjjrSU4SjjrU4SjrSrU=r $) SumOverBatchSizeMetricWrapperizAWraps a function with the `SumOverBatchSizeMetricWrapper` metric.c 8>[TU]X#S9 XlX@lg)a:Creates a `SumOverBatchSizeMetricWrapper` instance. Args: fn: The metric function to wrap, with signature `fn(y_true, y_pred, **kwargs)`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. **kwargs: The keyword arguments that are passed on to `fn`. rNr.r1s r$r&SumOverBatchSizeMetricWrapper.__init__s d0 r&c>[R"XR5n[R"X R5n[R"X!5up![R R RUR[R R R55nU"X40URD6n[R"U5n[R"XSX`R5n[TU]=XSS9$)Nr)rrr r rr+r,r.r/r-r0r5r6rrr=r7s r$r=*SumOverBatchSizeMetricWrapper.update_states--%BB  ))44 HHboo//BBD :$//:$$W-$55 D.. w#G#IIr&cd>URR5VVs0sH9upU[R"U5(a[R "U5OU_M; nnn[ TU]5n[[UR55[UR55-5$s snnfr)) r0rnr r?rr@rrmrVr rBs r$rm(SumOverBatchSizeMetricWrapper.get_configs--/ / ("@"@"C"Cw||A J/  g(* D**,-V\\^0DDEE  sAB,rJrr)) rorrrrrr=rmrrrs@r$rsrssK !J"FFr&rscj[U[5(a[R"5(a)URR UR 55$[R"5 URR UR 55sSSS5 $U$!,(df  U$=f)zFReturns a clone of the metric if stateful, otherwise returns it as is.N) r>rr rr#rtrmrrW)rs r$ clone_metricr{s&&!!  ) ) + +##//0A0A0CD D''33F4E4E4GH! M! Ms .)B## B2cJ[RR[U5$)z"Clones the given metric list/dict.)rrR map_structurer{)rs r$ clone_metricsr~s 77 w 77r&cURRSR[RR S5SS55$)Nrb)r startswithrlrsplit)rFs r$r<r<s= >> $ $ ""((-cr23 r&c,^\rSrSrSrU4SjrSrU=r$)rWiz+Wrapper for returned dictionary of metrics.c 4>[TU]"S0UD6 SUlg)Nr)rrrX)r!r"r#s r$r_MetricDict.__init__s "6"r&)rXrqrs@r$rWrWs5  r&rW)/rrrArnumpyrhtensorflow.compat.v2compatv2r tf_keras.srcrtf_keras.src.dtensorrrrr$tf_keras.src.enginerrr&tf_keras.src.saving.legacy.saved_modelr tf_keras.src.utilsr r r r tensorflow.python.util.tf_exportrtensorflow.tools.docsrLayerABCMetarrrr'r,rMrmrsr{r~r<rVrWrr&r$rsM !! 77*0,G,+,':.$%U"Z  U"&U"p qVqh!"# &# ## L"#+ 6+ $+ \/0dAdA1dAN()GG*GT v .(F$4(FV  8   $ r&