o 2h@sddlZddlmZddlmZddlmZddlmZddlmZddl m Z ddl m Z dd l mZGd d d e Zed Gd ddeZedGdddeZedGdddeZedGdddeZedGddde ZedGddde ZGddde Zed Gd!d"d"eZed#Gd$d%d%eZed&Gd'd(d(eZed)Gd*d+d+eZed,Gd-d.d.e ZdS)/N) activations)backend) initializers)ops) keras_export) metrics_utils)Metric)to_listcsBeZdZdZ d fdd Zd ddZddZfd d ZZS) _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. Ncs\tj||d||_||_tj|dd|_t|j|_|j t |jft dd|_ dS)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_condrr r  __class__^/var/www/html/chatgem/venv/lib/python3.10/site-packages/keras/src/metrics/confusion_metrics.pyrs   z'_ConfusionMatrixConditionCount.__init__cCs"tj|j|ji|||j|j|dS)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'r$r$r% update_state.s z+_ConfusionMatrixConditionCount.update_statecCs*t|jdkr |jd}n|j}t|SNr)rrrrconvert_to_tensorr resultr$r$r%r1As  z%_ConfusionMatrixConditionCount.resultc d|ji}t}i||S)Nr)rr get_configr config base_configr"r$r%r3H   z)_ConfusionMatrixConditionCount.get_configNNNN) __name__ __module__ __qualname____doc__rr,r1r3 __classcell__r$r$r"r%r s r zkeras.metrics.FalsePositivesc"eZdZdZdfdd ZZS)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 Nctjtjj|||ddSN)r!rr r )rrrConfusionMatrixFALSE_POSITIVESr rr r r"r$r%rq  zFalsePositives.__init__r8r:r;r<r=rr>r$r$r"r%r@N!r@zkeras.metrics.FalseNegativescr?)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 NcrArB)rrrrCFALSE_NEGATIVESrEr"r$r%rrFzFalseNegatives.__init__r8rGr$r$r"r%rIzrHrIzkeras.metrics.TrueNegativescr?) 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 NcrArB)rrrrCTRUE_NEGATIVESrEr"r$r%rrFzTrueNegatives.__init__r8rGr$r$r"r%rKrHrKzkeras.metrics.TruePositivescr?) 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 NcrArB)rrrrCTRUE_POSITIVESrEr"r$r%rrFzTruePositives.__init__r8rGr$r$r"r%rMrHrMzkeras.metrics.PrecisioncJeZdZdZ d fdd ZdddZddZd d Zfd d ZZ 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)]) ``` Nctj||dd|_||_||_||_|durdntj}tj||d|_ t |j |_ |j t |j ftdd|_|j t |j ftdd|_dS)Nr uprrtrue_positivesrfalse_positives)rr _directionrtop_kclass_idrNEG_INFrrrrrrrrrSrTr rrVrWr r rr"r$r%rQ*    zPrecision.__init__c C:tjtjj|jtjj|ji|||j|j|j |j |ddS)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&rVrWr'N) rr(rCrNrSrDrTrrrVrWr)r$r$r%r,n   zPrecision.update_statecC4t|jt|j|j}t|jdkr|dS|Sr-)r divide_no_nanrSaddrTrrr0r$r$r%r1 zPrecision.resultcC:tt|j}|jt|f|jt|fdSr9)rr rrSassignrzerosrTr num_thresholdsr$r$r% reset_statezPrecision.reset_statec(|j|j|jd}t}i||SN)rrVrWrrVrWrr3r4r"r$r%r3   zPrecision.get_configNNNNNr9 r:r;r<r=rr,r1rgr3r>r$r$r"r%rPsR rPzkeras.metrics.RecallcrO)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)]) ``` NcrQ)Nr rRrrrSrfalse_negatives)rrrUrrVrWrrXrrrrrrrrrSrprYr"r$r%rrZzRecall.__init__c Cr[)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`. r\N) rr(rCrNrSrJrprrrVrWr)r$r$r%r,r]zRecall.update_statecCr^r-)rr_rSr`rprrr0r$r$r%r1raz Recall.resultcCrbr9)rr rrSrcrrdrprer$r$r%rgrhzRecall.reset_statecrirjrkr4r"r$r%r3$rlzRecall.get_configrmr9rnr$r$r"r%rosB rocsJeZdZdZ dfdd ZdddZdd Zfd d Zd d ZZ 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). Ncstj||dd|_dkrtd||_||_dkr(dg|_d|_nfdd td D}d g|d g|_d |_|j t |jft dd|_ |j t |jft dd|_|j t |jft dd|_|j t |jft dd|_dS)Nr rRrzKArgument `num_thresholds` must be an integer > 0. Received: num_thresholds=r.rFc g|] }|dddqSr.?r$.0irfr$r% Iz7SensitivitySpecificityBase.__init__..ruTrSrrTtrue_negativesrp)rrrU ValueErrorvaluerWrrrangerrrrrSrTr~rp)r rrfrWr r rr"ryr%r5sL       z#SensitivitySpecificityBase.__init__c CsJtjtjj|jtjj|jtjj|jtjj |j i|||j |j |j |ddS)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&rWr'N)rr(rCrNrSrLr~rDrTrJrprrrWr)r$r$r%r,es     z'SensitivitySpecificityBase.update_statecCs^t|j}|jt|f|jt|f|jt|f|jt|fdSr9) rrrSrcrrdrTr~rprer$r$r%rg~s z&SensitivitySpecificityBase.reset_statecr2)NrW)rWrr3r4r"r$r%r3r7z%SensitivitySpecificityBase.get_configcCsHt|||j}tt|d}tjt||dd}t||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_dependentr$r$r%_find_max_under_constraintsz5SensitivitySpecificityBase._find_max_under_constraintrrNNNr9) r:r;r<r=rr,rgr3rr>r$r$r"r%rq.s 0 rqz&keras.metrics.SensitivityAtSpecificityc>eZdZdZ    d fdd ZddZfdd ZZS) 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)]) ``` rrNcD|dks|dkrtd|||_||_tj|||||ddS)Nrr.zJArgument `specificity` must be in the range [0, 1]. Received: specificity=rfrWr r )r specificityrfrr)r rrfrWr r r"r$r%r z!SensitivityAtSpecificity.__init__cCsDt|jt|j|j}t|jt|j|j}|||tjSr9 rr_rSr`rpr~rTr greater_equalr sensitivities specificitiesr$r$r%r1zSensitivityAtSpecificity.resultc$|j|jd}t}i||S)N)rfr)rfrrr3r4r"r$r%r3   z#SensitivityAtSpecificity.get_configrr:r;r<r=rr1r3r>r$r$r"r%r< rz&keras.metrics.SpecificityAtSensitivitycr) 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(sensitivity=0.3)]) ``` rrNcr)Nrr.zJArgument `sensitivity` must be in the range [0, 1]. Received: sensitivity=r)r sensitivityrfrr)r rrfrWr r r"r$r%rErz!SpecificityAtSensitivity.__init__cCsDt|jt|j|j}t|jt|j|j}|||tjSr9rrr$r$r%r1\rzSpecificityAtSensitivity.resultcr)N)rfr)rfrrr3r4r"r$r%r3irz#SpecificityAtSensitivity.get_configrrr$r$r"r%r rrzkeras.metrics.PrecisionAtRecallcs8eZdZdZ d fdd ZddZfdd ZZS) 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)]) ``` rrNcr)Nrr.z@Argument `recall` must be in the range [0, 1]. Received: recall=rrfrWr r )rrecallrfrr)r rrfrWr r r"r$r%rs zPrecisionAtRecall.__init__cCsDt|jt|j|j}t|jt|j|j}|||tjSr9rr_rSr`rprTrrr recalls precisionsr$r$r%r1rzPrecisionAtRecall.resultcr)N)rfr)rfrrr3r4r"r$r%r3s  zPrecisionAtRecall.get_configrrr$r$r"r%rrs 1 rzkeras.metrics.RecallAtPrecisioncr) 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)]) ``` rrNcr)Nrr.zFArgument `precision` must be in the range [0, 1]. Received: precision=r)r precisionrfrr)r rrfrWr r r"r$r%rrzRecallAtPrecision.__init__cCsDt|jt|j|j}t|jt|j|j}|||tjSr9rrr$r$r%r1rzRecallAtPrecision.resultcr)N)rfr)rfrrr3r4r"r$r%r3"rzRecallAtPrecision.get_configrrr$r$r"r%rs6 rzkeras.metrics.AUCcsxeZdZdZ          dfdd Zed d Zd d Zdd dZddZ ddZ ddZ fddZ Z 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)]) ``` rrROC interpolationNFc sd|_t|tjr|ttjvrtd|dttjt|tjr7|ttjvr7td|dttj|du|_|dur[t|d|_ t |}t t dg|dg|_ndkrftd |_ fd d tdD}d |_t dtg|dtg|_t|tjr||_ntj||_t|tjr||_ntj||_tj||d ||_||_| durtj | |jd} | |_nd|_| |_d|_|jr|rd|g} || dSdS|rtd|ddS)NrRz Invalid `curve` argument value "z". Expected one of: z+Invalid `summation_method` argument value "r|r}rur.zKArgument `num_thresholds` must be an integer > 1. Received: num_thresholds=crsrtr$rvryr$r%rzr{z AUC.__init__..Tr )r Fz7`num_labels` is needed only when `multi_label` is True.) rU isinstancerAUCCurvelistrAUCSummationMethod_init_from_thresholdsrrfsortedrnparrayrrrepsilon _thresholdscurvefrom_strsummation_methodrr multi_label num_labelsrr label_weights _from_logits_built_build) r rfrrr r rrrr from_logitsrr"ryr%rs     z AUC.__init__cCs t|jS)z'The thresholds used for evaluating AUC.)rr)r r$r$r%r s zAUC.thresholdscCs|jr!t|dkrtdt|d||d|_|j|jg}n|jg}||_|j|tdd|_ |j|tdd|_ |j|tdd|_ |j|td d|_ d |_ d S) zKInitialize TP, FP, TN, and FN tensors, given the shape of the data.r|z>`y_pred` must have rank 2 when `multi_label=True`. Found rank z$. Full shape received for `y_pred`: r.rSrrTr~rpTN)rrr _num_labelsrf_build_input_shaperrrrSrTr~rpr)r rvariable_shaper$r$r%rsD   z AUC._buildc Cs~|js ||j|jrdn|j}|jrt|}tj tj j |j tj j |jtj j|jtj j|ji|||j|j||j|ddS)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)r&r'rr)rrrrrrrsigmoidrr(rCrNrSrLr~rDrTrJrprr)r r*r+r'rr$r$r%r,7s&       zAUC.update_statec Cst|jd|jd|jdd}t|j|j}t|d|jd|dd}t|t|d}t|jddt||dd}t t |d|jddk|dddkt|d|jdt|dddt |dd}tt|t|t|t |tt|jdd|j ddd}|jrtj|dd}|jdurt|Sttt||jt|jSt|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. Nr.raxis)rsubtractrSrfr`rTr_maximummultiplyr logical_and ones_likelogrprsumrmean) r dtppdp prec_slope intercept safe_p_ratiopr_auc_increment by_label_aucr$r$r%interpolate_pr_auc]sF/ "("      zAUC.interpolate_pr_aucc CsL|jtjjkr|jtjjkr|St |j t |j |j }|jtjj kr8t |jt |j|j}|}|}ne|jtjjkrQt |j t |j |j}|}|}nLt t |j |j t |j|j}d|t |j |j }d|t |j|j }tt|j dd|}tt|j dd|}t|d}|}|}|jtjjkrtt |d|jd|ddd} n*|jtjjkrt|d|jd|dd} nt|d|jd|dd} tt|d|jd|dd| } |jr!tj| dd} |jdurt| St tt| |jt|jSt| S)Nrur}r.g@rr)rrrPRrr INTERPOLATIONrrr_rSr`rprrTr~requalrdividerfMINORINGminimumrrrrrr) r rfp_ratexyrscaling_factor recall_gainprecision_gainheights riemann_termsrr$r$r%r1s~ "$""    z AUC.resultcCsr|jr7|jr |j|jf}n|jf}|jt||jt||j t||j t|dSdSr9) rrrfrrSrcrrdrTr~rp)r rr$r$r%rgszAUC.reset_statecsX|j}|j|jj|jj|j|j||jd}|jr!|j dd|d<t }i||S)N)rfrrrrrrr.r) rrfrrrrrrrrrr3)r rr5r6r"r$r%r3*s   zAUC.get_config) rrrrNNNFNNFr9)r:r;r<r=rpropertyrrr,rr1rgr3r>r$r$r"r%r+s*yf  (&Zg r)numpyr keras.srcrrrrkeras.src.api_exportrkeras.src.metricsrkeras.src.metrics.metricrkeras.src.utils.python_utilsr r r@rIrKrMrProrqrrrrrr$r$r$r%sF        A++++ tggVa