6biSrSSKrSSKrSSKJs Jr SSKJ r SSKJ r SSK J r SSKJr SSKJr SSKJr SS KJr SS KJr "S S \R05r\"S 5"SS\55r\"S5"SS\55r\"S5"SS\55r\"S5"SS\55r\"S5"SS\R055r\"S5"SS\R055r"SS \R0\R@S!9r!\"S"5"S#S$\!55r"\"S%5"S&S'\!55r#\"S(5"S)S*\!55r$\"S+5"S,S-\!55r%\"S.5"S/S0\R055r&g)1zHConfusion metrics, i.e. metrics based on True/False positives/negatives.N) activations)backend)utils) base_metric) metrics_utils)to_list)is_tensor_or_variable) keras_exportcT^\rSrSrSrS U4SjjrS SjrSrSrU4Sjr Sr U=r $) _ConfusionMatrixConditionCount"aOCalculates the number of the given confusion matrix condition. Args: confusion_matrix_cond: One of `metrics_utils.ConfusionMatrix` conditions. thresholds: (Optional) A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. Defaults to `0.5`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. c >[TU]X4S9 XlX l[R "USS9Ul[R"UR 5UlURS[UR 54SS9Ul g)Nnamedtype?default_threshold accumulatorzerosshape initializer) super__init___confusion_matrix_condinit_thresholdsrparse_init_thresholds thresholds is_evenly_distributed_thresholds_thresholds_distributed_evenly add_weightlenr)selfconfusion_matrix_condrrr __class__s `/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/metrics/confusion_metrics.pyr'_ConfusionMatrixConditionCount.__init__0s d0&;#)'== #   : :4?? K + ?? #doo"6!8g+ c [R"URUR0UUURUR US9$)aAAccumulates the metric statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Defaults to `1`. Returns: Update op. )rthresholds_distributed_evenly sample_weight)r!update_confusion_matrix_variablesrrrr!r$y_truey_predr,s r' update_state+_ConfusionMatrixConditionCount.update_state@sD>>  ( ($*:*: ;  *.*M*M'   r)c[UR5S:XaURSnO URn[R"U5$Nr)r#rrtfconvert_to_tensorr$results r'r9%_ConfusionMatrixConditionCount.resultVs? t 1 $%%a(F%%F##F++r)c [R"URVs/sH2o[R"UR R 554PM4 sn5 gs snfN)rbatch_set_value variablesnprras_list)r$vs r' reset_state*_ConfusionMatrixConditionCount.reset_state]s@7;~~ F~!!''//+, -~ F Fs9A c>SUR0n[TU] 5n[[ UR 55[ UR 55-5$)Nr)rr get_configdictlistitemsr$config base_configr&s r'rE)_ConfusionMatrixConditionCount.get_configbsI 4 45g(* D**,-V\\^0DDEEr))rr!rrrNNNr<) __name__ __module__ __qualname____firstlineno____doc__rr1r9rBrE__static_attributes__ __classcell__r&s@r'r r "s/ HL  ,, FFr)r zkeras.metrics.FalsePositivescN^\rSrSrSr\R SU4Sjj5rSrU=r $)FalsePositivesha?Calculates the number of false positives. If `sample_weight` is given, calculates the sum of the weights of false positives. This metric creates one local variable, `accumulator` that is used to keep track of the number of false positives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) A float value, or a Python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). If used with a loss function that sets `from_logits=True` (i.e. no sigmoid applied to predictions), `thresholds` should be set to 0. One metric value is generated for each threshold value. Defaults to `0.5`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.FalsePositives() >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.FalsePositives()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.FalsePositives(thresholds=0)]) ``` cV>[TU][RRUUUS9 gN)r%rrr)rrrConfusionMatrixFALSE_POSITIVESr$rrrr&s r'rFalsePositives.__init__- "/"?"?"O"O!  r)rM rNrOrPrQrR dtensor_utils inject_meshrrSrTrUs@r'rWrWh#/b  r)rWzkeras.metrics.FalseNegativescN^\rSrSrSr\R SU4Sjj5rSrU=r $)FalseNegativesa?Calculates the number of false negatives. If `sample_weight` is given, calculates the sum of the weights of false negatives. This metric creates one local variable, `accumulator` that is used to keep track of the number of false negatives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) A float value, or a Python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). If used with a loss function that sets `from_logits=True` (i.e. no sigmoid applied to predictions), `thresholds` should be set to 0. One metric value is generated for each threshold value. Defaults to `0.5`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.FalseNegatives() >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.FalseNegatives()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.FalseNegatives(thresholds=0)]) ``` cV>[TU][RRUUUS9 grZ)rrrr[FALSE_NEGATIVESr]s r'rFalseNegatives.__init__r_r)r`rMrarUs@r'rfrfrdr)rfzkeras.metrics.TrueNegativescN^\rSrSrSr\R SU4Sjj5rSrU=r $) TrueNegativesa9Calculates the number of true negatives. If `sample_weight` is given, calculates the sum of the weights of true negatives. This metric creates one local variable, `accumulator` that is used to keep track of the number of true negatives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) A float value, or a Python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). If used with a loss function that sets `from_logits=True` (i.e. no sigmoid applied to predictions), `thresholds` should be set to 0. One metric value is generated for each threshold value. Defaults to `0.5`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.TrueNegatives() >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.TrueNegatives()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.TrueNegatives(thresholds=0)]) ``` cV>[TU][RRUUUS9 grZ)rrrr[TRUE_NEGATIVESr]s r'rTrueNegatives.__init__- "/"?"?"N"N!  r)r`rMrarUs@r'rlrlrdr)rlzkeras.metrics.TruePositivescN^\rSrSrSr\R SU4Sjj5rSrU=r $) TruePositivesia<Calculates the number of true positives. If `sample_weight` is given, calculates the sum of the weights of true positives. This metric creates one local variable, `true_positives` that is used to keep track of the number of true positives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) A float value, or a Python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). If used with a loss function that sets `from_logits=True` (i.e. no sigmoid applied to predictions), `thresholds` should be set to 0. One metric value is generated for each threshold value. Defaults to `0.5`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.TruePositives() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.TruePositives()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.TruePositives(thresholds=0)]) ``` cV>[TU][RRUUUS9 grZ)rrrr[TRUE_POSITIVESr]s r'rTruePositives.__init__Rrqr)r`rMrarUs@r'rsrsrdr)rszkeras.metrics.Precisioncr^\rSrSrSr\R S U4Sjj5rS SjrSr Sr U4Sjr Sr U=r $) Precisioni\a Computes the precision of the predictions with respect to the labels. The metric creates two local variables, `true_positives` and `false_positives` that are used to compute the precision. This value is ultimately returned as `precision`, an idempotent operation that simply divides `true_positives` by the sum of `true_positives` and `false_positives`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `top_k` is set, we'll calculate precision as how often on average a class among the top-k classes with the highest predicted values of a batch entry is correct and can be found in the label for that entry. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold and/or in the top-k highest predictions, and computing the fraction of them for which `class_id` is indeed a correct label. Args: thresholds: (Optional) A float value, or a Python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). If used with a loss function that sets `from_logits=True` (i.e. no sigmoid applied to predictions), `thresholds` should be set to 0. One metric value is generated for each threshold value. If neither thresholds nor top_k are set, the default is to calculate precision with `thresholds=0.5`. top_k: (Optional) Unset by default. An int value specifying the top-k predictions to consider when calculating precision. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Precision() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result().numpy() 0.6666667 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 >>> # With top_k=2, it will calculate precision over y_true[:2] >>> # and y_pred[:2] >>> m = tf.keras.metrics.Precision(top_k=2) >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1]) >>> m.result().numpy() 0.0 >>> # With top_k=4, it will calculate precision over y_true[:4] >>> # and y_pred[:4] >>> m = tf.keras.metrics.Precision(top_k=4) >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.Precision()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.Precision(thresholds=0)]) ``` c>[TU]XES9 XlX lX0lUcSO[ R n[ R"XS9Ul[ R"UR5Ul URS[UR54SS9Ul URS[UR54SS9Ulg)Nrrrtrue_positivesrrfalse_positives)rrrtop_kclass_idrNEG_INFrrr r!r"r#rzr{r$rr|r}rrrr&s r'rPrecision.__init__ d0)  #(=Cm6K6K'==    : :4?? K +#oo S%9$;.  $ t') / r)c [R"[RRUR[RR UR 0UUURURURURUS9$)aAccumulates true positive and false positive statistics. Args: y_true: The ground truth values, with the same dimensions as `y_pred`. Will be cast to `bool`. y_pred: The predicted values. Each element must be in the range `[0, 1]`. sample_weight: Optional weighting of each example. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Defaults to `1`. Returns: Update op. rr+r|r}r,) rr-r[rurzr\r{rr!r|r}r.s r'r1Precision.update_states>>--<Q>Q--==t?S?S   *.*M*M**]]'  r)c[RRUR[RR URUR 55n[ UR5S:XaUS$U$r4)r6math divide_no_nanrzaddr{r#rr8s r'r9Precision.result^&&    GGKK++T-A-A B  0A5vayA6Ar)c [[UR55n[R"UR UR 4Vs/sHnU[R"U454PM sn5 gs snfr<) r#rrrr=rzr{r?rr$num_thresholdsrAs r'rBPrecision.reset_stategWT__56--t/C/CD DABHHn./0D    #A4c>URURURS.n[TU]5n[ [ UR55[ UR55-5$N)rr|r}rr|r}rrErFrGrHrIs r'rEPrecision.get_configY..ZZ   g(* D**,-V\\^0DDEEr))r!r}r{rrr|rzNNNNNr<rNrOrPrQrRrbrcrr1r9rBrErSrTrUs@r'rxrx\sCN`KO  0 :B FFr)rxzkeras.metrics.Recallcr^\rSrSrSr\R S U4Sjj5rS SjrSr Sr U4Sjr Sr U=r $) Recallia Computes the recall of the predictions with respect to the labels. This metric creates two local variables, `true_positives` and `false_negatives`, that are used to compute the recall. This value is ultimately returned as `recall`, an idempotent operation that simply divides `true_positives` by the sum of `true_positives` and `false_negatives`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `top_k` is set, recall will be computed as how often on average a class among the labels of a batch entry is in the top-k predictions. If `class_id` is specified, we calculate recall by considering only the entries in the batch for which `class_id` is in the label, and computing the fraction of them for which `class_id` is above the threshold and/or in the top-k predictions. Args: thresholds: (Optional) A float value, or a Python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). If used with a loss function that sets `from_logits=True` (i.e. no sigmoid applied to predictions), `thresholds` should be set to 0. One metric value is generated for each threshold value. If neither thresholds nor top_k are set, the default is to calculate recall with `thresholds=0.5`. top_k: (Optional) Unset by default. An int value specifying the top-k predictions to consider when calculating recall. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Recall() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result().numpy() 0.6666667 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.Recall()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.Recall(thresholds=0)]) ``` c>[TU]XES9 XlX lX0lUcSO[ R n[ R"XS9Ul[ R"UR5Ul URS[UR54SS9Ul URS[UR54SS9Ulg)Nrrrrzrrfalse_negatives)rrrr|r}rr~rrr r!r"r#rzrrs r'rRecall.__init__@rr)c [R"[RRUR[RR UR 0UUURURURURUS9$)aAccumulates true positive and false negative statistics. Args: y_true: The ground truth values, with the same dimensions as `y_pred`. Will be cast to `bool`. y_pred: The predicted values. Each element must be in the range `[0, 1]`. sample_weight: Optional weighting of each example. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Defaults to `1`. Returns: Update op. r) rr-r[rurzrirrr!r|r}r.s r'r1Recall.update_stateYrr)c[RRUR[RR URUR 55n[ UR5S:XaUS$U$r4)r6rrrzrrr#rr8s r'r9 Recall.resultvrr)c [[UR55n[R"UR UR 4Vs/sHnU[R"U454PM sn5 gs snfr<) r#rrrr=rzrr?rrs r'rBRecall.reset_state}rrc>URURURS.n[TU]5n[ [ UR55[ UR55-5$rrrIs r'rERecall.get_configrr))r!r}rrrr|rzrr<rrUs@r'rrsB>@KO  0 :B FFr)rcT^\rSrSrSrS U4SjjrS SjrSrU4SjrSr Sr U=r $) SensitivitySpecificityBaseizAbstract base class for computing sensitivity and specificity. For additional information about specificity and sensitivity, see [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity). c>[TU]XES9 US::a[SU35eXlX0lUR SU4SS9UlUR SU4SS9UlUR SU4SS9UlUR S U4SS9Ul US :XaS /Ul S Ul g[US - 5Vs/sHnUS -S-US - - PM nnS/U-S/-Ul SUl gs snf)NrrzKArgument `num_thresholds` must be an integer > 0. Received: num_thresholds=rzrrtrue_negativesr{rr5rF?T) rr ValueErrorvaluer}r"rzrr{rrr!range) r$rrr}rrirr&s r'r#SensitivitySpecificityBase.__init__sI d0 Q ,,:+;=   "oo ^$57. #oo ^$57.  $ n%6G /  $ n%6G /  Q "eDO27D /~122AQ# !!342  #ej0C58DO26D / s1C"c [R"[RRUR[RR UR [RRUR[RRUR0UUURURURUS9$)GAccumulates confusion matrix statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Defaults to `1`. Returns: Update op. )rr+r}r,)rr-r[rurzrorr\r{rirrr!r}r.s r'r1'SensitivitySpecificityBase.update_states>>--<Q>Q--<Q>Q--==t?S?S--==t?S?S    *.*M*M]]'  r)c [UR5nURURURUR 4n[ R"UVs/sHnU[R"U454PM sn5 gs snfr<) r#rrzrr{rrr=r?r)r$rconfusion_matrix_variablesrAs r'rB&SensitivitySpecificityBase.reset_statesT__-         & " 4 3ABHHn./03   s#Bc>SUR0n[TU] 5n[[ UR 55[ UR 55-5$)Nr})r}rrErFrGrHrIs r'rE%SensitivitySpecificityBase.get_configsGdmm,g(* D**,-V\\^0DDEEr)c&[R"U"XR55n[R"[R"U5S5n[R "[R "X$55n[R"XVS5$)a^Returns the maximum of dependent_statistic that satisfies the constraint. Args: constrained: Over these values the constraint is specified. A rank-1 tensor. dependent: From these values the maximum that satiesfies the constraint is selected. Values in this tensor and in `constrained` are linked by having the same threshold at each position, hence this tensor must have the same shape. predicate: A binary boolean functor to be applied to arguments `constrained` and `self.value`, e.g. `tf.greater`. Returns: maximal dependent value, if no value satiesfies the constraint 0.0. rr)r6wherergreatersize reduce_maxgather)r$ constrained dependent predicatefeasiblefeasible_exists max_dependents r'_find_max_under_constraint5SensitivitySpecificityBase._find_max_under_constraints\"88Ik::>?**RWWX%6: bii &DE xx<= specified value. the sensitivity at a given specificity. `Sensitivity` measures the proportion of actual positives that are correctly identified as such (tp / (tp + fn)). `Specificity` measures the proportion of actual negatives that are correctly identified as such (tn / (tn + fp)). This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the sensitivity at the given specificity. The threshold for the given specificity value is computed and used to evaluate the corresponding sensitivity. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. For additional information about specificity and sensitivity, see [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity). Args: specificity: A scalar value in range `[0, 1]`. num_thresholds: (Optional) The number of thresholds to use for matching the given specificity. Defaults to `200`. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.SensitivityAtSpecificity(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8], ... sample_weight=[1, 1, 2, 2, 1]) >>> m.result().numpy() 0.333333 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.SensitivityAtSpecificity()]) ``` ct>US:dUS:a[SU35eXlX l[TU]UUUUUS9 g)Nrr5zJArgument `specificity` must be in the range [0, 1]. Received: specificity=rr}rr)r specificityrrr)r$rrr}rrr&s r'r!SensitivityAtSpecificity.__init__@] ?kAo))4 7 ',  )  r)c[RRUR[RR URUR 55n[RRUR [RR UR UR55nURX[R5$r<) r6rrrrr{rzrr greater_equal)r$ specificities sensitivitiess r'r9SensitivityAtSpecificity.resultX--    GGKK++T-A-A B --    GGKK++T-A-A B .. "*:*:  r)c>URURS.n[TU] 5n[ [ UR 55[ UR 55-5$)Nrr)rrrrErFrGrHrIs r'rE#SensitivityAtSpecificity.get_configeT"11++ g(* D**,-V\\^0DDEEr)rr rNrOrPrQrRrbrcrr9rErSrTrUs@r'rrsB9v    .  FFr)rz&keras.metrics.SpecificityAtSensitivitych^\rSrSrSr\R SU4Sjj5rSrU4Sjr Sr U=r $)SpecificityAtSensitivityinaComputes best specificity where sensitivity is >= specified value. `Sensitivity` measures the proportion of actual positives that are correctly identified as such (tp / (tp + fn)). `Specificity` measures the proportion of actual negatives that are correctly identified as such (tn / (tn + fp)). This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the specificity at the given sensitivity. The threshold for the given sensitivity value is computed and used to evaluate the corresponding specificity. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. For additional information about specificity and sensitivity, see [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity). Args: sensitivity: A scalar value in range `[0, 1]`. num_thresholds: (Optional) The number of thresholds to use for matching the given sensitivity. Defaults to `200`. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.SpecificityAtSensitivity(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result().numpy() 0.66666667 >>> m.reset_state() >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8], ... sample_weight=[1, 1, 2, 2, 2]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.SpecificityAtSensitivity()]) ``` ct>US:dUS:a[SU35eXlX l[TU]UUUUUS9 g)Nrr5zJArgument `sensitivity` must be in the range [0, 1]. Received: sensitivity=r)r sensitivityrrr)r$rrr}rrr&s r'r!SpecificityAtSensitivity.__init__rr)c[RRUR[RR URUR 55n[RRUR [RR UR UR55nURX[R5$r<) r6rrrzrrrr{rr)r$rrs r'r9SpecificityAtSensitivity.resultrr)c>URURS.n[TU] 5n[ [ UR 55[ UR 55-5$)Nrr)rrrrErFrGrHrIs r'rE#SpecificityAtSensitivity.get_configrr)rrrrUs@r'rrnsB7r    .  FFr)rzkeras.metrics.PrecisionAtRecallcb^\rSrSrSr\R SU4Sjj5rSrU4Sjr Sr U=r $)PrecisionAtRecalliaiComputes best precision where recall is >= specified value. This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the precision at the given recall. The threshold for the given recall value is computed and used to evaluate the corresponding precision. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. Args: recall: A scalar value in range `[0, 1]`. num_thresholds: (Optional) The number of thresholds to use for matching the given recall. Defaults to `200`. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.PrecisionAtRecall(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8], ... sample_weight=[2, 2, 2, 1, 1]) >>> m.result().numpy() 0.33333333 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.PrecisionAtRecall(recall=0.8)]) ``` ct>US:dUS:a[SU35eXlX l[TU]UUUUUS9 g)Nrr5z@Argument `recall` must be in the range [0, 1]. Received: recall=rrr}rr)rrecallrrr)r$rrr}rrr&s r'rPrecisionAtRecall.__init__ s\ A:!$$*8-  , )  r)c[RRUR[RR URUR 55n[RRUR[RR URUR 55nURX[R5$r<) r6rrrzrrr{rr)r$recalls precisionss r'r9PrecisionAtRecall.results''''    GGKK++T-A-A B WW**    GGKK++T-A-A B .. !1!1  r)c>URURS.n[TU] 5n[ [ UR 55[ UR 55-5$)Nrr)rrrrErFrGrHrIs r'rEPrecisionAtRecall.get_config)sM$($7$74;;Og(* D**,-V\\^0DDEEr)rrrrUs@r'rrs7.`JN  $  FFr)rzkeras.metrics.RecallAtPrecisionch^\rSrSrSr\R SU4Sjj5rSrU4Sjr Sr U=r $)RecallAtPrecisioni/aComputes best recall where precision is >= specified value. For a given score-label-distribution the required precision might not be achievable, in this case 0.0 is returned as recall. This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the recall at the given precision. The threshold for the given precision value is computed and used to evaluate the corresponding recall. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. Args: precision: A scalar value in range `[0, 1]`. num_thresholds: (Optional) The number of thresholds to use for matching the given precision. Defaults to `200`. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.RecallAtPrecision(0.8) >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9], ... sample_weight=[1, 0, 0, 1]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[tf.keras.metrics.RecallAtPrecision(precision=0.8)]) ``` ct>US:dUS:a[SU35eXlX l[TU]UUUUUS9 g)Nrr5zFArgument `precision` must be in the range [0, 1]. Received: precision=r)r precisionrrr)r$rrr}rrr&s r'rRecallAtPrecision.__init__ds\ q=IM''0k3 #, )  r)c[RRUR[RR URUR 55n[RRUR[RR URUR 55nURX[R5$r<) r6rrrzrr{rrr)r$rrs r'r9RecallAtPrecision.result|sWW**    GGKK++T-A-A B ''''    GGKK++T-A-A B .. !1!1  r)c>URURS.n[TU] 5n[ [ UR 55[ UR 55-5$)Nrr)rrrrErFrGrHrIs r'rERecallAtPrecision.get_configsR"11 g(* D**,-V\\^0DDEEr)rrrrUs@r'rr/sB1f    .  FFr)rzkeras.metrics.AUCc^\rSrSrSr\R S U4Sjj5r\S5r Sr S Sjr Sr Sr S rU4S jrS rU=r$)AUCiaApproximates the AUC (Area under the curve) of the ROC or PR curves. The AUC (Area under the curve) of the ROC (Receiver operating characteristic; default) or PR (Precision Recall) curves are quality measures of binary classifiers. Unlike the accuracy, and like cross-entropy losses, ROC-AUC and PR-AUC evaluate all the operational points of a model. This class approximates AUCs using a Riemann sum. During the metric accumulation phrase, predictions are accumulated within predefined buckets by value. The AUC is then computed by interpolating per-bucket averages. These buckets define the evaluated operational points. This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the AUC. To discretize the AUC curve, a linearly spaced set of thresholds is used to compute pairs of recall and precision values. The area under the ROC-curve is therefore computed using the height of the recall values by the false positive rate, while the area under the PR-curve is the computed using the height of the precision values by the recall. This value is ultimately returned as `auc`, an idempotent operation that computes the area under a discretized curve of precision versus recall values (computed using the aforementioned variables). The `num_thresholds` variable controls the degree of discretization with larger numbers of thresholds more closely approximating the true AUC. The quality of the approximation may vary dramatically depending on `num_thresholds`. The `thresholds` parameter can be used to manually specify thresholds which split the predictions more evenly. For a best approximation of the real AUC, `predictions` should be distributed approximately uniformly in the range [0, 1] (if `from_logits=False`). The quality of the AUC approximation may be poor if this is not the case. Setting `summation_method` to 'minoring' or 'majoring' can help quantify the error in the approximation by providing lower or upper bound estimate of the AUC. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: num_thresholds: (Optional) The number of thresholds to use when discretizing the roc curve. Values must be > 1. Defaults to `200`. curve: (Optional) Specifies the name of the curve to be computed, 'ROC' [default] or 'PR' for the Precision-Recall-curve. summation_method: (Optional) Specifies the [Riemann summation method]( https://en.wikipedia.org/wiki/Riemann_sum) used. 'interpolation' (default) applies mid-point summation scheme for `ROC`. For PR-AUC, interpolates (true/false) positives but not the ratio that is precision (see Davis & Goadrich 2006 for details); 'minoring' applies left summation for increasing intervals and right summation for decreasing intervals; 'majoring' does the opposite. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. thresholds: (Optional) A list of floating point values to use as the thresholds for discretizing the curve. If set, the `num_thresholds` parameter is ignored. Values should be in [0, 1]. Endpoint thresholds equal to {-epsilon, 1+epsilon} for a small positive epsilon value will be automatically included with these to correctly handle predictions equal to exactly 0 or 1. multi_label: boolean indicating whether multilabel data should be treated as such, wherein AUC is computed separately for each label and then averaged across labels, or (when False) if the data should be flattened into a single label before AUC computation. In the latter case, when multilabel data is passed to AUC, each label-prediction pair is treated as an individual data point. Should be set to False for multi-class data. num_labels: (Optional) The number of labels, used when `multi_label` is True. If `num_labels` is not specified, then state variables get created on the first call to `update_state`. label_weights: (Optional) list, array, or tensor of non-negative weights used to compute AUCs for multilabel data. When `multi_label` is True, the weights are applied to the individual label AUCs when they are averaged to produce the multi-label AUC. When it's False, they are used to weight the individual label predictions in computing the confusion matrix on the flattened data. Note that this is unlike class_weights in that class_weights weights the example depending on the value of its label, whereas label_weights depends only on the index of that label before flattening; therefore `label_weights` should not be used for multi-class data. from_logits: boolean indicating whether the predictions (`y_pred` in `update_state`) are probabilities or sigmoid logits. As a rule of thumb, when using a keras loss, the `from_logits` constructor argument of the loss should match the AUC `from_logits` constructor argument. Standalone usage: >>> m = tf.keras.metrics.AUC(num_thresholds=3) >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9]) >>> # threshold values are [0 - 1e-7, 0.5, 1 + 1e-7] >>> # tp = [2, 1, 0], fp = [2, 0, 0], fn = [0, 1, 2], tn = [0, 2, 2] >>> # tp_rate = recall = [1, 0.5, 0], fp_rate = [1, 0, 0] >>> # auc = ((((1+0.5)/2)*(1-0)) + (((0.5+0)/2)*(0-0))) = 0.75 >>> m.result().numpy() 0.75 >>> m.reset_state() >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9], ... sample_weight=[1, 0, 0, 1]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python # Reports the AUC of a model outputting a probability. model.compile(optimizer='sgd', loss=tf.keras.losses.BinaryCrossentropy(), metrics=[tf.keras.metrics.AUC()]) # Reports the AUC of a model outputting a logit. model.compile(optimizer='sgd', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.AUC(from_logits=True)]) ``` c r>[U[R5(aEU[[R5;a([ SUS[[R535e[U[R 5(aEU[[R 5;a([ SUS[[R 535eUSLUlUbV[U5S-Ul[U5n[R"[R"S/U-S/-55Ul OKUS::a[ SU35eXl[US- 5V s/sHn U S-S-US- - PM nn S Ul [R"S[R "5- /U-S[R "5-/-5Ul[U[R5(aX lO$[RR'U5Ul[U[R 5(aX0lO$[R R'U5Ul[*T U]YXES 9 XplXlU bC[2R4"XR6S 9n [2R8R;U S S 9 XlOSUlXlSUl UR.(a2U(a*[2RB"SU/5n UREU 5 ggU(a [ S5eURES5 gs sn f)Nz Invalid `curve` argument value "z". Expected one of: z+Invalid `summation_method` argument value "rrrr5zKArgument `num_thresholds` must be an integer > 1. Received: num_thresholds=Tr)rz3All values of `label_weights` must be non-negative.messageFz7`num_labels` is needed only when `multi_label` is True.)# isinstancerAUCCurverGrAUCSummationMethod_init_from_thresholdsr#rsortedr r?arrayr!rrepsilon _thresholdscurvefrom_strsummation_methodrr multi_label num_labelsr6constantr debuggingassert_non_negative label_weights _from_logits_built TensorShape_build)r$rr r rrrrrr from_logitsrrr&s r'r AUC.__init__ s  e]33 4 4d  " "G : 25':$$()?)?$@#AC   m>>  d=+K+K&LL##3"45$$()I)I$J#KM &0t%;"  !"%j/A"5D  +J>>HHcUZ/3%78  / " 00>/?A#1 ~122AQ# !!342 37D /88 7??$ $ % 2cGOO`y_pred` must have rank 2 when `multi_label=True`. Found rank z$. Full shape received for `y_pred`: r5rzrrrr{rNT)rndimsr _num_labelsr6rr_build_input_shaper"rzrr{r init_scopeexecuting_eagerlyr_initialize_variables _get_sessionr)r$rvariable_shapes r'r AUC._buildvs_   {{a ""'++/99>A %QxD ^^$$d&6&67N ^^T-@-@,ABN"'"oo N. #oo N.  $ ^ /  $ ^ /    ++--11'2F2F2HI ! !s AE-- E;c "UR(d/UR[R"UR55 UR (d UR bUS4/nUR (aEURURS4URS4URS4URS4/5 UR b;URUR S45 [RRUSS9 UR (aSO UR nUR(a[ R""U5n[$R&"[$R(R*UR[$R(R,UR[$R(R.UR[$R(R0UR0UUUR2UR4UUR US9$)rN)NL)Tr()r(z#Number of labels is not consistent.r)r+r,rr)rrr6rrrrextendrzrr{rappendr assert_shapesrrsigmoidrr-r[ruror\rir r!)r$r/r0r,shapesrs r'r1AUC.update_states{{ KKv||4 5    2 2 >z*+F ,,j9,,j9--z:--z: !!- t116:; **$I+!% 0 0d6H6H    ((0F>>--<Q>Q--<Q>Q--==t?S?S--==t?S?S       *.*M*M'(('  r)c URSURS- URSS- n[RR URUR 5nUSURS- USS- n[RR U[R"US5SS9nURSS[R"XBSS5- n[R"[R"USURS- S:USSS:5[RR USURS- [R"USSS5SS9[R"USS55n[RR XAU[RRU5---[R"URSSURSS-S5SS9nUR(a[R"XpR S-SS 9nUR"c[R$"XR S9$[RR [R"[R"XR"55[R"UR"5UR S9$[R"US S9$) aInterpolation formula inspired by section 4 of Davis & Goadrich 2006. https://www.biostat.wisc.edu/~page/rocpr.pdf Note here we derive & use a closed formula not present in the paper as follows: Precision = TP / (TP + FP) = TP / P Modeling all of TP (true positive), FP (false positive) and their sum P = TP + FP (predicted positive) as varying linearly within each interval [A, B] between successive thresholds, we get Precision slope = dTP / dP = (TP_B - TP_A) / (P_B - P_A) = (TP - TP_A) / (P - P_A) Precision = (TP_A + slope * (P - P_A)) / P The area within the interval is (slope / total_pos_weight) times int_A^B{Precision.dP} = int_A^B{(TP_A + slope * (P - P_A)) * dP / P} int_A^B{Precision.dP} = int_A^B{slope * dP + intercept * dP / P} where intercept = TP_A - slope * P_A = TP_B - slope * P_B, resulting in int_A^B{Precision.dP} = TP_B - TP_A + intercept * log(P_B / P_A) Bringing back the factor (slope / total_pos_weight) we'd put aside, we get slope * [dTP + intercept * log(P_B / P_A)] / total_pos_weight where dTP == TP_B - TP_A. Note that when P_A == 0 the above calculation simplifies into int_A^B{Precision.dTP} = int_A^B{slope * dTP} = slope * (TP_B - TP_A) which is really equivalent to imputing constant precision throughout the first bucket having >0 true positives. Returns: pr_auc: an approximation of the area under the P-R curve. Nr5r prec_sloperrecall_relative_ratiopr_auc_increment _by_labelraxisinterpolate_pr_auc)rzrr6rrr{rmaximummultiplyr logical_and ones_likelogrr reduce_sumrr reduce_mean) r$dtppdpr1 intercept safe_p_ratior4 by_label_aucs r'r8AUC.interpolate_pr_aucs\    9$"5"5"9 :!!!"% &  GGKK++T-A-A B ($$q( )AabE 1WW** B"+ ''+bkk*e.LL xx NN16t22Q67!;QqrUQY G GG ! !+D''!+, 1QR5!$, "  LL12  7700  BGGKK ,E EE F JJt**12.1E1Eab1II1 M#1    == yy;'>QL!!)~~lCCww,,MM L2D2DEMM$"4"45 -==!18LM Mr)cjUR[RR:Xa8UR[R R :XaUR5$[RRUR[RRURUR55nUR[RR:Xaa[RRUR[RRURUR 55nUnUnO`[RRUR[RRURUR55nUnUnUR[R R :XaUSUR"S- USS-S- nO}UR[R R$:Xa+[R&"USUR"S- USS5nO*[R("USUR"S- USS5nUR*(a[R,"USUR"S- USS- U5n[R."XpR0S-SS9nUR2c[R4"XR0S9$[RR[R."[R,"XR255[R."UR25UR0S9$[R."[R,"USUR"S- USS- U5UR0S9$)Nr5g@r5rr6r2)r rrPRr r INTERPOLATIONr8r6rrrzrrROCr{rrMINORINGminimumr9rr:r>rrr?) r$rfp_ratexyrheights riemann_termsrEs r'r9 AUC.result9s JJ-0033 3%%//==>**, ,&&    GGKK++T-A-A B  :://33 3gg++$$ D00$2E2EFGAA--## D//1E1EFIAA  ! !//== >24..23ae;sBG  " "m&F&F&O&O Ojj#[UR5(a![R"UR5nO URnURUR R URR URURUURS.nUR(aURSSUS'[TU]95n[[!UR#55[!UR#55-5$)N)rr r rrrrr5r)r rrevalrr rr rrrrrrrErFrGrH)r$rrJrKr&s r'rEAUC.get_configs !3!3 4 4#LL););risO !!$ 7,,4=:CF[%7%7CFL,-9 39 .9 x,-9 39 .9 x+,9 29 -9 x+,9 29 -9 x'(^F ""^F)^FB$%NF[  NF&NFbp=!3!3s{{p=f67gF9gF8gFT67eF9eF8eFP/0TF2TF1TFn/0_F2_F1_FD!"XF+  XF#XFr)