&VfPddlZddlmZddlmZddlmZddlmZddlmZddl 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 ZdS)/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. Nc^t||||_||_t j|d|_t j|j|_| t|jftj d|_ 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_condrrr __class__s `/var/www/html/software/conda/lib/python3.11/site-packages/keras/src/metrics/confusion_metrics.pyrz'_ConfusionMatrixConditionCount.__init__s d%000&;#)'= #     :4? K K + ,,t'')$*,,-  cbtj|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.s@>  ($*: ;  *.*M'     r'ct|jdkr|jd}n|j}tj|SNr)r!rrrconvert_to_tensorr#results r&r5z%_ConfusionMatrixConditionCount.resultAs? t  1 $ $%a(FF%F(000r'cbd|ji}t}i||S)Nr)rr get_configr#config base_configr%s r&r7z)_ConfusionMatrixConditionCount.get_configHs5 45gg((** (+(((r'NNNN) __name__ __module__ __qualname____doc__rr/r5r7 __classcell__r%s@r&r r s  HL      $    &111)))))))))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 Ncpttjj|||dSN)r$rrr)rrrConfusionMatrixFALSE_POSITIVESr#rrrr%s r&rzFalsePositives.__init__q@ "/"?"O!      r'r;r=r>r?r@rrArBs@r&rDrDNHB          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 Ncpttjj|||dSrF)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 Ncpttjj|||dSrF)rrrrGTRUE_NEGATIVESrIs r&rzTrueNegatives.__init__@ "/"?"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 Ncpttjj|||dSrF)rrrrGTRUE_POSITIVESrIs r&rzTruePositives.__init__rUr'r;rKrBs@r&rWrWrLr'rWzkeras.metrics.PrecisioncDeZdZdZ dfd Zd dZdZdZfdZxZ 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)]) ``` Nct||d|_||_||_||_|dn t j}t j|||_ t j |j |_ | t|j ftjd|_| t|j ftjd|_dS)Nruprrtrue_positivesrfalse_positives)rr _directionrtop_kclass_idrNEG_INFrrrrr r!rr"r^r_r#rrarbrrrr%s r&rzPrecision.__init__Q  d%000)   #(=CCm6K'= *;     :4? K K +#//t'')$*,,!0   $00t'')$*,," 1  r'c tjtjj|jtjj|ji|||j|j|j |j |dS)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_stateni 7-Q-=t?S   *.*M*]' r'ctj|jtj|j|j}t |jdkr|dn|Sr1)r divide_no_nanr^addr_r!rr4s r&r5zPrecision.resultS"   GD')= > >   00A55vayy6Ar'ctt|j}|jt j|f|jt j|fdSr<)r!r rr^assignrzerosr_r#num_thresholdss r& reset_statezPrecision.reset_stategWT_5566 ""39n->#?#?@@@ ##CI~.?$@$@AAAAAr'cz|j|j|jd}t}i||SN)rrarbrrarbrr7r8s r&r7zPrecision.get_configF.Z    gg((** (+(((r'NNNNNr< r=r>r?r@rr/r5rrr7rArBs@r&r[r[sOOdLP      :    4BBBBBB )))))))))r'r[zkeras.metrics.RecallcDeZdZdZ dfd Zd dZdZdZfdZxZ 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)]) ``` Nct||d|_||_||_||_|dn t j}t j|||_ t j |j |_ | t|j ftjd|_| t|j ftjd|_dS)Nrr]rrr^rfalse_negatives)rrr`rrarbrrcrrrrr r!rr"r^r}rds r&rzRecall.__init__rer'c tjtjj|jtjj|ji|||j|j|j |j |dS)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 |jdkr|dn|Sr1)rrjr^rkr}r!rr4s r&r5z Recall.resultrlr'ctt|j}|jt j|f|jt j|fdSr<)r!r rr^rnrror}rps r&rrzRecall.reset_statersr'cz|j|j|jd}t}i||Srurvr8s r&r7zRecall.get_config$rwr'rxr<ryrBs@r&r{r{s??DLP      :    4BBBBBB )))))))))r'r{cDeZdZdZ d fd Zd dZdZfdZdZxZ 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). NcFt||d|_dkrtd||_||_dkrdg|_d|_n4fdtd z D}d g|zd gz|_d |_| t|jftj d |_ | t|jftj d|_| t|jftj d|_| t|jftj d|_dS)Nrr]rzKArgument `num_thresholds` must be an integer > 0. Received: num_thresholds=r2rFc,g|]}|dzdzdz z Sr2?.0irqs r& z7SensitivitySpecificityBase.__init__..I;Q# !!34r'rTr^rr_true_negativesr})rrr` ValueErrorvaluerbrrranger r!rr"r^r_rr})r#rrqrbrrrr%s ` r&rz#SensitivitySpecificityBase.__init__5s d%000 Q  =,:==     Q  "eDO27D / /~122J #ej0C58DO26D /"//t'')$*,,!0   $00t'')$*,," 1   #//t'')$*,,!0   $00t'')$*,," 1  r'c  tjtjj|jtjj|jtjj|jtjj |j i|||j |j |j |dS)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 7-Q-Q-=t?S-=t?S    *.*M]' r'ct|j}|jt j|f|jt j|f|jt j|f|jt j|fdSr<) r!rr^rnrror_rr}rps r&rrz&SensitivitySpecificityBase.reset_state~sT_-- ""39n->#?#?@@@ ##CI~.?$@$@AAA ""39n->#?#?@@@ ##CI~.?$@$@AAAAAr'cbd|ji}t}i||S)Nrb)rbrr7r8s r&r7z%SensitivitySpecificityBase.get_configs4dm,gg((** (+(((r'c8tjtj|||j}tjtj|d}tjtj||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) rconvert_to_numpyrnonzerorgreatersizemaxtakewhere)r# constrained dependent predicatefeasiblefeasible_exists max_dependents r&_find_max_under_constraintz5SensitivitySpecificityBase._find_max_under_constraints"+ K +tz:: ; ;  +chx&8&8!<<H = =qIII y-===r'rNNNr<) r=r>r?r@rr/rrr7rrArBs@r&rr.sJN. . . . . . `    2BBB))))) >>>>>>>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()]) ``` rNc|dks|dkrtd|||_||_t|||||dS)Nrr2zJArgument `specificity` must be in the range [0, 1]. Received: specificity=rqrbrr)r specificityrqrr)r#rrqrbrrr%s r&rz!SensitivityAtSpecificity.__init__ ??kAoo7)477 ',  )      r'c tj|jtj|j|j}tj|jtj|j|j}|||tjSr< rrjr^rkr}rr_r greater_equalr# sensitivities specificitiess r&r5zSensitivityAtSpecificity.result)   GD')= > >  )   GD')= > >  .. =#*;   r'cn|j|jd}t}i||S)N)rqr)rqrrr7r8s r&r7z#SensitivityAtSpecificity.get_configB"1+  gg((** (+(((r'rr=r>r?r@rr5r7rArBs@r&rr~77x        .    )))))))))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()]) ``` rNc|dks|dkrtd|||_||_t|||||dS)Nrr2zJArgument `sensitivity` must be in the range [0, 1]. Received: sensitivity=r)r sensitivityrqrr)r#rrqrbrrr%s r&rz!SpecificityAtSensitivity.__init__Hrr'c tj|jtj|j|j}tj|jtj|j|j}|||tjSr<rrs r&r5zSpecificityAtSensitivity.result_rr'cn|j|jd}t}i||S)N)rqr)rqrrr7r8s r&r7z#SpecificityAtSensitivity.get_configlrr'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)]) ``` rNc|dks|dkrtd|||_||_t|||||dS)Nrr2z@Argument `recall` must be in the range [0, 1]. Received: recall=rrqrbrr)rrecallrqrr)r#rrqrbrrr%s r&rzPrecisionAtRecall.__init__s A::!-$*--  , )      r'c tj|jtj|j|j}tj|jtj|j|j}|||tjSr<rrjr^rkr}r_rrr#recalls precisionss r&r5zPrecisionAtRecall.results#   GD')= > >  &   GD')= > >  .. Z!2   r'cn|j|jd}t}i||S)N)rqr)rqrrr7r8s r&r7zPrecisionAtRecall.get_configs:$($74;OOgg((** (+(((r'rrrBs@r&rrusw..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)]) ``` rNc|dks|dkrtd|||_||_t|||||dS)Nrr2zFArgument `precision` must be in the range [0, 1]. Received: precision=r)r precisionrqrr)r#rrqrbrrr%s r&rzRecallAtPrecision.__init__s q==IMM3'033 #, )      r'c tj|jtj|j|j}tj|jtj|j|j}|||tjSr<rrs r&r5zRecallAtPrecision.results#   GD')= > >  &   GD')= > >  .. !2   r'cn|j|jd}t}i||S)N)rqr)rqrrr7r8s r&r7zRecallAtPrecision.get_config%sA"1  gg((** (+(((r'rrrBs@r&rrs~11l        .    )))))))))r'rzkeras.metrics.AUCcxeZdZdZ dfd ZedZd Zdd Zd Z d Z d Z fdZ 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)]) ``` rROC interpolationNFc d|_t|tjrG|t tjvr,t d|dt tjt|tjrG|t tjvr,t d|dt tj|du|_|Zt|dz|_ t|}tj tj dg|zdgz|_nDdkrt d |_ fd tdz D}d |_tj dt!jz g|zdt!jzgz|_t|tjr||_n$tj||_t|tjr||_n$tj||_t-|| ||_||_| #t5j | |j } | |_nd|_| |_d|_|jr|rd|g} || dSdS|rt d|ddS)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=c,g|]}|dzdzdz z Srrrs r&rz AUC.__init__..rr'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_logitsrr%s ` r&rz AUC.__init__s e]3 4 4 d  "G G : : C5CC$()?$@$@CC   m>   d=+K&L&LLLM#3MM$()I$J$JMM &0t%;"  !"%j//A"5D  ++J>HcUZ/3%788  / / "" A0>AA#1D ~122J37D /8 7?$$ $ % 2cGO`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._builds\   35zzQ A"%e**AA9>AA %QxD "143CDNN"12N"'"// $*,,!0   $00 $*,," 1   #// $*,,!0   $00 $*,," 1    r'c |js||j|js|jd|dfg}|jr5||jdf|jdf|jdf|j dfg|j| |jdf|jrdn|j}|j rtj |}tjtjj|jtjj|jtjj|jtjj|j i|||j|j||j|dS)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_state:so{ & KK % % %   < 2 >z*+F  ,j9,j9-z:-z: !- t16:;;; !% 0Hd6H   1 (00F7-Q-Q-=t?S-=t?S      *.*M'('      r'ctj|jd|jdz |jdd}tj|j|j}tj|d|jdz |dd}tj|tj|d}tj|jddtj||dd}tj tj |d|jdz dk|dddktj|d|jdz tj|dddtj |dd}tjtj|tj|tj|tj |tjtj|jdd|j ddd}|jrtj|d}|jtj|Stjtjtj||jtj|jStj|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_aucss^l   9$"5"9 9 :   #   GD')= > > \!5d1A556!"" > >&sCKA,>,>?? L   #S\*ae%D%D  y OA7 3a 7781>**,, ,"   GD')= > >   :/3 3 3'$,d.ABBGAAA)#+T-ABBIAA  !/= > >j3D/!334ae<!""FFGGk!$=d&9A&=$=">!""FFG L4T01445qu = =w     *7=q999L!)x ---(GCLt7IJJKKGD.// 7=)) )r'c|jr|jr|j|jf}n|jf}|jt j||jt j||j t j||j t j|dSdSr<) rrrqrr^rnrror_rr})r#rs r&rrzAUC.reset_state s ; C 8"&"5t7G!H"&"5!7   & &sy'@'@ A A A  ' ' .(A(A B B B   & &sy'@'@ A A A  ' ' .(A(A B B B B B C Cr'c|j}|j|jj|jj|j|j||jd}|jr|j dd|d<t }i||S)N)rqrrrrrrr2r) rrqrrrrrrrrrr7)r#rr9r:r%s r&r7zAUC.get_configs* "1Z% $ 5 ;+/*,    % 9$(?1R4#8F< gg((** (+(((r') rrrNNNFNNFr<)r=r>r?r@rpropertyrrr/r r5rrr7rArBs@r&rr.suur( ddddddL&&X&&&&P7 7 7 7 rX-X-X-t=*=*=*~ C C C)))))))))r'r)numpyr keras.srcrrrrkeras.src.api_exportrkeras.src.metricsrkeras.src.metrics.metricr keras.src.utils.python_utilsr r rDrNrRrWr[r{rrrrrrrr'r&r!s+!!!!!!""""""------++++++++++++000000>)>)>)>)>)V>)>)>)B,--( ( ( ( ( 3( ( .-( V,--( ( ( ( ( 3( ( .-( V+,,( ( ( ( ( 2( ( -,( V+,,( ( ( ( ( 2( ( -,( V'((\)\)\)\)\)\)\))(\)~$%%L)L)L)L)L)VL)L)&%L)^t>t>t>t>t>t>t>t>n677d)d)d)d)d)9d)d)87d)N677d)d)d)d)d)9d)d)87d)N/00S)S)S)S)S)2S)S)10S)l/00^)^)^)^)^)2^)^)10^)B!""|)|)|)|)|)&|)|)#"|)|)|)r'