2Vhi|ddlZddlmZddlmZddlmZddlmZddlmZddl m Z ddl m Z dd l mZGd d e Zed Gd deZedGddeZedGddeZedGddeZedGdde ZedGdde ZGdde Zed Gd!d"eZed#Gd$d%eZed&Gd'd(eZed)Gd*d+eZed,Gd-d.e Zy)/N) activations)backend) initializers)ops) keras_export) metrics_utils)Metric)to_listc>eZdZdZ dfd ZddZdZfdZxZS)_ConfusionMatrixConditionCountaCalculates the number of the given confusion matrix condition. Args: confusion_matrix_cond: One of `metrics_utils.ConfusionMatrix` conditions. thresholds: (Optional) Defaults to `0.5`. 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. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. cBt|||||_||_t j |d|_t j|j |_|jt|j ftjd|_ y)Nnamedtype?default_threshold accumulatorshape initializerr)super__init___confusion_matrix_condinit_thresholdsrparse_init_thresholds thresholds is_evenly_distributed_thresholds_thresholds_distributed_evenly add_variablelenrZerosr)selfconfusion_matrix_condrrr __class__s S/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/metrics/confusion_metrics.pyrz'_ConfusionMatrixConditionCount.__init__s d%0&;#)'== #   : :4?? K + ,,t')$**,- ctj|j|ji|||j|j |S)anAccumulates the metric statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to `1`. Can be a tensor whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. )rthresholds_distributed_evenly sample_weight)r!update_confusion_matrix_variablesrrrrr#y_truey_predr*s r& update_statez+_ConfusionMatrixConditionCount.update_state.sD>>  ( ($*:*: ;  *.*M*M'   r'ct|jdk(r|jd}n |j}tj|SNr)r!rrrconvert_to_tensorr#results r&r5z%_ConfusionMatrixConditionCount.resultAs? t 1 $%%a(F%%F((00r'cHd|ji}t| }i||S)Nr)rr get_configr#config base_configr%s r&r7z)_ConfusionMatrixConditionCount.get_configHs0 4 45g(* (+(((r'NNNN) __name__ __module__ __qualname____doc__rr/r5r7 __classcell__r%s@r&r r s( HL $ &1))r'r zkeras.metrics.FalsePositivesc$eZdZdZdfd ZxZS)FalsePositivesa 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) Defaults to `0.5`. 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. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Examples: >>> m = keras.metrics.FalsePositives() >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1]) >>> m.result() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result() 1.0 c\t|tjj|||yN)r$rrr)rrrConfusionMatrixFALSE_POSITIVESr#rrrr%s r&rzFalsePositives.__init__q- "/"?"?"O"O!  r'r;r=r>r?r@rrArBs@r&rDrDNB  r'rDzkeras.metrics.FalseNegativesc$eZdZdZdfd ZxZS)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) Defaults to `0.5`. 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. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Example: >>> m = keras.metrics.FalseNegatives() >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0]) >>> m.result() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0], sample_weight=[0, 0, 1, 0]) >>> m.result() 1.0 c\t|tjj|||yrF)rrrrGFALSE_NEGATIVESrIs r&rzFalseNegatives.__init__rJr'r;rKrBs@r&rNrNzrLr'rNzkeras.metrics.TrueNegativesc$eZdZdZdfd ZxZS) TrueNegativesaCalculates 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) Defaults to `0.5`. 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. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Example: >>> m = keras.metrics.TrueNegatives() >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0]) >>> m.result() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0], sample_weight=[0, 0, 1, 0]) >>> m.result() 1.0 c\t|tjj|||yrF)rrrrGTRUE_NEGATIVESrIs r&rzTrueNegatives.__init__- "/"?"?"N"N!  r'r;rKrBs@r&rRrRrLr'rRzkeras.metrics.TruePositivesc$eZdZdZdfd ZxZS) TruePositivesa 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) Defaults to `0.5`. 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. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Example: >>> m = keras.metrics.TruePositives() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result() 1.0 c\t|tjj|||yrF)rrrrGTRUE_POSITIVESrIs r&rzTruePositives.__init__rUr'r;rKrBs@r&rWrWrLr'rWzkeras.metrics.PrecisioncDeZdZdZ dfd ZddZdZdZfdZxZ S) Precisiona 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. Example: >>> m = keras.metrics.Precision() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result() 0.6666667 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result() 1.0 >>> # With top_k=2, it will calculate precision over y_true[:2] >>> # and y_pred[:2] >>> m = keras.metrics.Precision(top_k=2) >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1]) >>> m.result() 0.0 >>> # With top_k=4, it will calculate precision over y_true[:4] >>> # and y_pred[:4] >>> m = keras.metrics.Precision(top_k=4) >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1]) >>> m.result() 0.5 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[keras.metrics.Precision()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=keras.losses.BinaryCrossentropy(from_logits=True), metrics=[keras.metrics.Precision(thresholds=0)]) ``` ct|||d|_||_||_||_|dnt j}t j|||_ t j|j|_ |jt|jftjd|_|jt|jftjd|_y)Nruprrtrue_positivesrfalse_positives)rr _directionrtop_kclass_idrNEG_INFrrrrr r!rr"r^r_r#rrarbrrrr%s r&rzPrecision.__init__Q d%0)   #(=Cm6K6K'== *;   : :4?? K +#//t')$**,!0  $00t')$**," 1 r'c tjtjj|jtjj |j i|||j|j|j|j|y)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. Defaults to `1`. Can be a tensor whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. rr)rarbr*N) rr+rGrYr^rHr_rrrarbr,s r&r/zPrecision.update_statenn 77--<Q>Q--==t?S?S   *.*M*M**]]' r'ctj|jtj|j|j}t |j dk(r|dS|Sr1)r divide_no_nanr^addr_r!rr4s r&r5zPrecision.resultV""    GGD'')=)= >  0A5vayA6Ar'ctt|j}|jj t j |f|jj t j |fyr<)r!r rr^assignrzerosr_r#num_thresholdss r& reset_statezPrecision.reset_stateUWT__56 ""399n->#?@ ##CII~.?$@Ar'ct|j|j|jd}t|}i||SN)rrarbrrarbrr7r8s r&r7zPrecision.get_config@..ZZ   g(* (+(((r'NNNNNr< r=r>r?r@rr/r5rrr7rArBs@r&r[r[s1OdLP : 4BB ))r'r[zkeras.metrics.RecallcDeZdZdZ dfd ZddZdZdZfdZxZ S) Recalla 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. Example: >>> m = keras.metrics.Recall() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result() 0.6666667 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=[keras.metrics.Recall()]) ``` Usage with a loss with `from_logits=True`: ```python model.compile(optimizer='adam', loss=keras.losses.BinaryCrossentropy(from_logits=True), metrics=[keras.metrics.Recall(thresholds=0)]) ``` ct|||d|_||_||_||_|dnt j}t j|||_ t j|j|_ |jt|jftjd|_|jt|jftjd|_y)Nrr]rrr^rfalse_negatives)rrr`rrarbrrcrrrrr r!rr"r^r}rds r&rzRecall.__init__rer'c tjtjj|jtjj |j i|||j|j|j|j|y)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. Defaults to `1`. Can be a tensor whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. rgN) rr+rGrYr^rPr}rrrarbr,s r&r/zRecall.update_staterhr'ctj|jtj|j|j}t |j dk(r|dS|Sr1)rrjr^rkr}r!rr4s r&r5z Recall.resultrlr'ctt|j}|jj t j |f|jj t j |fyr<)r!r rr^rnrror}rps r&rrzRecall.reset_statersr'ct|j|j|jd}t|}i||Srurvr8s r&r7zRecall.get_config$rwr'rxr<ryrBs@r&r{r{s0?DLP : 4BB ))r'r{cDeZdZdZ dfd ZddZdZfdZdZxZ S) SensitivitySpecificityBasezAbstract 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). ct|||d|_|dkrtd|||_||_|dk(rdg|_d|_n=t|dz Dcgc]}|dzd z|dz z }}d g|zd gz|_d |_|jt|j ftjd |_ |jt|j ftjd |_|jt|j ftjd |_|jt|j ftjd |_ycc}w)Nrr]rzKArgument `num_thresholds` must be an integer > 0. Received: num_thresholds=r2rF?Tr^rr_true_negativesr})rrr` ValueErrorvaluerbrrranger r!rr"r^r_rr}) r#rrqrbrrirr%s r&rz#SensitivitySpecificityBase.__init__5s d%0 Q ,,:+;=     Q "eDO27D /~12Q# !!34J #ej0C58DO26D /"//t')$**,!0  $00t')$**," 1  #//t')$**,!0  $00t')$**," 1 -s F c tjtjj|jtjj |j tjj|jtjj|ji|||j|j|j|y)atAccumulates confusion matrix statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to `1`. Can be a tensor whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. )rr)rbr*N)rr+rGrYr^rTrrHr_rPr}rrrbr,s r&r/z'SensitivitySpecificityBase.update_statees 77--<Q>Q--<Q>Q--==t?S?S--==t?S?S    *.*M*M]]' r'ct|j}|jjt j |f|j jt j |f|jjt j |f|jjt j |fyr<) r!rr^rnrror_rr}rps r&rrz&SensitivitySpecificityBase.reset_state~sT__- ""399n->#?@ ##CII~.?$@A ""399n->#?@ ##CII~.?$@Ar'cHd|ji}t| }i||S)Nrb)rbrr7r8s r&r7z%SensitivitySpecificityBase.get_configs.dmm,g(* (+(((r'c$tj|||j}tjtj|d}tj tj ||d}tj||dS)aReturns 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. `ops.greater`. Returns: maximal dependent value, if no value satisfies the constraint 0.0. r)initialr)rnonzerorgreatersizemaxtakewhere)r# constrained dependent predicatefeasiblefeasible_exists max_dependents r&_find_max_under_constraintz5SensitivitySpecificityBase._find_max_under_constraintsd";;ydjjAB++chhx&8!<H =qI yy-==r'NNNr<) r=r>r?r@rr/rrr7rrArBs@r&rr.s*JN. ` 2B) >r'rz&keras.metrics.SensitivityAtSpecificityc<eZdZdZ dfd ZdZfdZxZS)SensitivityAtSpecificityaComputes best sensitivity where specificity 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 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) Defaults to 200. The number of thresholds to use for matching the given specificity. 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. Example: >>> m = keras.metrics.SensitivityAtSpecificity(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result() 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() 0.333333 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[keras.metrics.SensitivityAtSpecificity(specificity=0.5)]) ``` cz|dks|dkDrtd|||_||_t||||||y)Nrr2zJArgument `specificity` must be in the range [0, 1]. Received: specificity=rqrbrr)r specificityrqrr)r#rrqrbrrr%s r&rz!SensitivityAtSpecificity.__init__a ?kAo))4 7 ',  )  r'cdtj|jtj|j|j}tj|j tj|j |j }|j||tjSr< rrjr^rkr}rr_r greater_equalr# sensitivities specificitiess r&r5zSensitivityAtSpecificity.result))    GGD'')=)= > ))    GGD'')=)= > .. =#*;*;  r'c^|j|jd}t| }i||S)N)rqr)rqrrr7r8s r&r7z#SensitivityAtSpecificity.get_config;"11++ g(* (+(((r'rr=r>r?r@rr5r7rArBs@r&rr+7x   .  ))r'rz&keras.metrics.SpecificityAtSensitivityc<eZdZdZ dfd ZdZfdZxZS)SpecificityAtSensitivityaComputes 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) Defaults to 200. The number of thresholds to use for matching the given sensitivity. 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. Example: >>> m = keras.metrics.SpecificityAtSensitivity(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result() 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() 0.5 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[keras.metrics.SpecificityAtSensitivity()]) ``` cz|dks|dkDrtd|||_||_t||||||y)Nrr2zJArgument `sensitivity` must be in the range [0, 1]. Received: sensitivity=r)r sensitivityrqrr)r#rrqrbrrr%s r&rz!SpecificityAtSensitivity.__init__Err'cdtj|jtj|j|j}tj|j tj|j |j }|j||tjSr<rrs r&r5zSpecificityAtSensitivity.result\rr'c^|j|jd}t| }i||S)N)rqr)rqrrr7r8s r&r7z#SpecificityAtSensitivity.get_configirr'rrrBs@r&rr rr'rzkeras.metrics.PrecisionAtRecallc6eZdZdZ dfd ZdZfdZxZS)PrecisionAtRecallaComputes 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) Defaults to 200. The number of thresholds to use for matching the given 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. Example: >>> m = keras.metrics.PrecisionAtRecall(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result() 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() 0.33333333 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[keras.metrics.PrecisionAtRecall(recall=0.8)]) ``` cz|dks|dkDrtd|||_||_t||||||y)Nrr2z@Argument `recall` must be in the range [0, 1]. Received: recall=rrqrbrr)rrecallrqrr)r#rrqrbrrr%s r&rzPrecisionAtRecall.__init__s` A:!$$*8-  , )  r'cdtj|jtj|j|j}tj|jtj|j|j }|j ||tjSr<rrjr^rkr}r_rrr#recalls precisionss r&r5zPrecisionAtRecall.results##    GGD'')=)= > &&    GGD'')=)= > .. Z!2!2  r'c^|j|jd}t| }i||S)N)rqr)rqrrr7r8s r&r7zPrecisionAtRecall.get_configs4$($7$74;;Og(* (+(((r'rrrBs@r&rrrs$.bKO $  ))r'rzkeras.metrics.RecallAtPrecisionc<eZdZdZ dfd ZdZfdZxZS)RecallAtPrecisionagComputes 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) Defaults to 200. The number of thresholds to use for matching the given 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. Example: >>> m = keras.metrics.RecallAtPrecision(0.8) >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9]) >>> m.result() 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() 1.0 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='binary_crossentropy', metrics=[keras.metrics.RecallAtPrecision(precision=0.8)]) ``` cz|dks|dkDrtd|||_||_t||||||y)Nrr2zFArgument `precision` must be in the range [0, 1]. Received: precision=r)r precisionrqrr)r#rrqrbrrr%s r&rzRecallAtPrecision.__init__s` q=IM''0k3 #, )  r'cdtj|jtj|j|j}tj|jtj|j|j }|j ||tjSr<rrs r&r5zRecallAtPrecision.results##    GGD'')=)= > &&    GGD'')=)= > .. !2!2  r'c^|j|jd}t| }i||S)N)rqr)rqrrr7r8s r&r7zRecallAtPrecision.get_config"s9"11 g(* (+(((r'rrrBs@r&rrs+1l   .  ))r'rzkeras.metrics.AUCcreZdZdZ d fd ZedZdZd dZdZ dZ dZ fd Z xZ S) AUCaApproximates 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. Example: >>> m = 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() 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() 1.0 Usage with `compile()` API: ```python # Reports the AUC of a model outputting a probability. model.compile(optimizer='sgd', loss=keras.losses.BinaryCrossentropy(), metrics=[keras.metrics.AUC()]) # Reports the AUC of a model outputting a logit. model.compile(optimizer='sgd', loss=keras.losses.BinaryCrossentropy(from_logits=True), metrics=[keras.metrics.AUC(from_logits=True)]) ``` c d|_t|tjrC|t tjvr(t d|dt tjt|tj rC|t tj vr(t d|dt tj |du|_|Tt|dz|_ t|}tjtjdg|zdgz|_nH|dkrt d |||_ t|dz D cgc]} | dzdz|dz z }} d |_tjdt!j"z g|zdt!j"zgz|_t|tjr||_n$tjj)||_t|tj r||_n$tj j)||_t, |]|| ||_||_| )t5j| |j6 } | |_nd|_| |_d |_|j0r|rd|g} |j?| yy|r t d|j?dycc} w)Nr]z Invalid `curve` argument value "z". Expected one of: z+Invalid `summation_method` argument value "rrrr2zKArgument `num_thresholds` must be an integer > 1. Received: num_thresholds=Tr)rFz7`num_labels` is needed only when `multi_label` is True.) r` isinstancerAUCCurvelistrAUCSummationMethod_init_from_thresholdsr!rqsortedrnparrayrrrepsilon _thresholdscurvefrom_strsummation_methodrr multi_label num_labelsrr label_weights _from_logits_built_build)r#rqrrrrrrrr from_logitsrrr%s r&rz AUC.__init__s e]33 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#1D ~12Q# !!34J37D /88 7??$ $ % 2cGOO`y_pred` must have rank 2 when `multi_label=True`. Found rank z$. Full shape received for `y_pred`: r2r^rr_rr}TN)rr!r _num_labelsrq_build_input_shaper rr"r^r_rr}r)r#rvariable_shapes r&rz AUC._builds4   5zQ ""%e*.99>A %QxD "1143C3CDN"112N"'"// $**,!0  $00 $**," 1  #// $**,!0  $00 $**," 1   r'c |js|j|j|js |j|dfg}|jrE|j |j df|jdf|jdf|jdfg|j|j|jdf|jrdn |j}|jrtj|}tjtj j"|j tj j$|jtj j&|jtj j(|ji|||j*|j,||j|y)aAccumulates 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`. N)NL)Tr)r)r)r*rr)rrrrrextendr^rr_r}appendrrsigmoidrr+rGrYrTrHrPrr)r#r-r.r*shapesrs r&r/zAUC.update_state7s{{ KK %    2 2 >z*+F ,,j9,,j9--z:--z: !!- t116:; !% 0 0d6H6H    ((0F77--<Q>Q--<Q>Q--==t?S?S--==t?S?S       *.*M*M'((' r'ctj|jd|jdz |jdd}tj|j|j }tj|d|jdz |dd}tj |tj|d}tj|jddtj||dd}tjtj|d|jdz dkD|dddkDtj |d|jdz tj|dddtj|dd}tj tj|tj|tj|tj|tjtj|jdd|jddd}|jrtj|d}|j tj"|Stj tjtj||j tj|j Stj|S)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. Nr2raxis)rsubtractr^rqrkr_rjmaximummultiplyr logical_and ones_likelogr}rsumrmean) r#dtppdp prec_slope intercept safe_p_ratiopr_auc_increment by_label_aucs r&interpolate_pr_auczAUC.interpolate_pr_aucpsh^ll    9$"5"5"9 :    #  GGD'')=)= > \\!5d11A56!" >&&sCKKA,>? LL    #S\\*ae%D yy OOA7 3 3a 781tj tj|d|j"dz |ddd}nz|jtj j$k(r*tj&|d|j"dz |dd}n)tj(|d|j"dz |dd}tj*tj,|d|j"dz |dd|}|j.rtj0|d}|j2tj4|Stjtj0tj*||j2tj0|j2Stj0|S)Nr2g@rr)rrrPRrr INTERPOLATIONrrrjr^rkr}ROCr_rdividerqMINORINGminimumrrrrrrr) r#rfp_ratexyrheights riemann_termsrs r&r5z AUC.results JJ-0033 3%%//==>**, ,""    GGD'')=)= >  :://33 3''$$,,d.A.ABGAA))##++T-A-ABIAA  ! !//== >jj3D//!34ae!"FGkk!$=d&9&9A&=">!"FG LL4T00145qu =w    77=q9L!!)xx --((GGCLLt7I7IJKGGD../ 77=) )r'c|jr|jr|j|jf}n |jf}|jj t j||jj t j||jj t j||jj t j|yyr<) rrrqrr^rnrror_rr})r#rs r&rrzAUC.reset_state s ;;"&"5"5t7G7G!H"&"5"5!7    & &syy'@ A  ' ' .(A B    & &syy'@ A  ' ' .(A B r'c4|j}|j|jj|jj|j |j ||jd}|jr|jdd|d<t|-}i||S)N)rqrrrrrrr2r) rrqrrrrrrrrrr7)r#rr9r:r%s r&r7zAUC.get_configs** "11ZZ%% $ 5 5 ; ;++//*,,   % %$(??1R#8F< g(* (+(((r') rr interpolationNNNFNNFr<)r=r>r?r@rpropertyrrr/rr5rrr7rArBs@r&rr+snur( dL&&&P7 rX-t=*~ C))r'r)numpyr keras.srcrrrrkeras.src.api_exportrkeras.src.metricsrkeras.src.metrics.metricr keras.src.utils.python_utilsr r rDrNrRrWr[r{rrrrrrr'r&rs!"-++0>)V>)B,-( 3( .( V,-( 3( .( V+,( 2( -( V+,( 2( -( V'(\)\))\)~$%L)VL)&L)^q>q>h67d)9d)8d)N67d)9d)8d)N/0S)2S)1S)l/0^)2^)1^)B!"|)&|)#|)r'