# Copyright 2015 The TensorFlow Authors. All Rights Reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ==============================================================================

"""Confusion metrics, i.e. metrics based on True/False positives/negatives."""

import abc

import numpy as np

import tensorflow.compat.v2 as tf

from keras import activations

from keras import backend

from keras.dtensor import utils as dtensor_utils

from keras.metrics import base_metric

from keras.utils import metrics_utils

from keras.utils.generic_utils import to_list

from keras.utils.tf_utils import is_tensor_or_variable

# isort: off

from tensorflow.python.util.tf_export import keras_export

class _ConfusionMatrixConditionCount(base_metric.Metric):

"""Calculates 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.

"""

def __init__(

self, confusion_matrix_cond, thresholds=None, name=None, dtype=None

):

super().__init__(name=name, dtype=dtype)

self._confusion_matrix_cond = confusion_matrix_cond

self.init_thresholds = thresholds

self.thresholds = metrics_utils.parse_init_thresholds(

thresholds, default_threshold=0.5

)

self._thresholds_distributed_evenly = (

metrics_utils.is_evenly_distributed_thresholds(self.thresholds)

)

self.accumulator = self.add_weight(

"accumulator", shape=(len(self.thresholds),), initializer="zeros"

)

def update_state(self, y_true, y_pred, sample_weight=None):

"""Accumulates 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`.

Returns:

Update op.

"""

return metrics_utils.update_confusion_matrix_variables(

{self._confusion_matrix_cond: self.accumulator},

y_true,

y_pred,

thresholds=self.thresholds,

thresholds_distributed_evenly=self._thresholds_distributed_evenly,

sample_weight=sample_weight,

)

def result(self):

if len(self.thresholds) == 1:

result = self.accumulator[0]

else:

result = self.accumulator

return tf.convert_to_tensor(result)

def reset_state(self):

backend.batch_set_value(

[(v, np.zeros(v.shape.as_list())) for v in self.variables]

)

def get_config(self):

config = {"thresholds": self.init_thresholds}

base_config = super().get_config()

return dict(list(base_config.items()) + list(config.items()))

@keras_export("keras.metrics.FalsePositives")

class FalsePositives(_ConfusionMatrixConditionCount):

"""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.

Standalone usage:

>>> m = tf.keras.metrics.FalsePositives()

>>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1])

>>> m.result().numpy()

2.0

>>> m.reset_state()

>>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1], sample_weight=[0, 0, 1, 0])

>>> m.result().numpy()

1.0

Usage with `compile()` API:

```python

model.compile(optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.FalsePositives()])

```

Usage with a loss with `from_logits=True`:

```python

model.compile(optimizer='adam',

loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

metrics=[tf.keras.metrics.FalsePositives(thresholds=0)])

```

"""

@dtensor_utils.inject_mesh

def __init__(self, thresholds=None, name=None, dtype=None):

super().__init__(

confusion_matrix_cond=metrics_utils.ConfusionMatrix.FALSE_POSITIVES,

thresholds=thresholds,

name=name,

dtype=dtype,

)

@keras_export("keras.metrics.FalseNegatives")

class FalseNegatives(_ConfusionMatrixConditionCount):

"""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.

Standalone usage:

>>> m = tf.keras.metrics.FalseNegatives()

>>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0])

>>> m.result().numpy()

2.0

>>> m.reset_state()

>>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0], sample_weight=[0, 0, 1, 0])

>>> m.result().numpy()

1.0

Usage with `compile()` API:

```python

model.compile(optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.FalseNegatives()])

```

Usage with a loss with `from_logits=True`:

```python

model.compile(optimizer='adam',

loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

metrics=[tf.keras.metrics.FalseNegatives(thresholds=0)])

```

"""

@dtensor_utils.inject_mesh

def __init__(self, thresholds=None, name=None, dtype=None):

super().__init__(

confusion_matrix_cond=metrics_utils.ConfusionMatrix.FALSE_NEGATIVES,

thresholds=thresholds,

name=name,

dtype=dtype,

)

@keras_export("keras.metrics.TrueNegatives")

class TrueNegatives(_ConfusionMatrixConditionCount):

"""Calculates 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.

Standalone usage:

>>> m = tf.keras.metrics.TrueNegatives()

>>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0])

>>> m.result().numpy()

2.0

>>> m.reset_state()

>>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0], sample_weight=[0, 0, 1, 0])

>>> m.result().numpy()

1.0

Usage with `compile()` API:

```python

model.compile(optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.TrueNegatives()])

```

Usage with a loss with `from_logits=True`:

```python

model.compile(optimizer='adam',

loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

metrics=[tf.keras.metrics.TrueNegatives(thresholds=0)])

```

"""

@dtensor_utils.inject_mesh

def __init__(self, thresholds=None, name=None, dtype=None):

super().__init__(

confusion_matrix_cond=metrics_utils.ConfusionMatrix.TRUE_NEGATIVES,

thresholds=thresholds,

name=name,

dtype=dtype,

)

@keras_export("keras.metrics.TruePositives")

class TruePositives(_ConfusionMatrixConditionCount):

"""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.

Standalone usage:

>>> m = tf.keras.metrics.TruePositives()

>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])

>>> m.result().numpy()

2.0

>>> m.reset_state()

>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])

>>> m.result().numpy()

1.0

Usage with `compile()` API:

```python

model.compile(optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.TruePositives()])

```

Usage with a loss with `from_logits=True`:

```python

model.compile(optimizer='adam',

loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

metrics=[tf.keras.metrics.TruePositives(thresholds=0)])

```

"""

@dtensor_utils.inject_mesh

def __init__(self, thresholds=None, name=None, dtype=None):

super().__init__(

confusion_matrix_cond=metrics_utils.ConfusionMatrix.TRUE_POSITIVES,

thresholds=thresholds,

name=name,

dtype=dtype,

)

@keras_export("keras.metrics.Precision")

class Precision(base_metric.Metric):

"""Computes the precision of the predictions with respect to the labels.

The metric creates two local variables, `true_positives` and

`false_positives` that are used to compute the precision. This value is

ultimately returned as `precision`, an idempotent operation that simply

divides `true_positives` by the sum of `true_positives` and

`false_positives`.

If `sample_weight` is `None`, weights default to 1.

Use `sample_weight` of 0 to mask values.

If `top_k` is set, we'll calculate precision as how often on average a class

among the top-k classes with the highest predicted values of a batch entry

is correct and can be found in the label for that entry.

If `class_id` is specified, we calculate precision by considering only the

entries in the batch for which `class_id` is above the threshold and/or in

the top-k highest predictions, and computing the fraction of them for which

`class_id` is indeed a correct label.

Args:

thresholds: (Optional) A float value, or a Python list/tuple of float

threshold values in [0, 1]. A threshold is compared with prediction

values to determine the truth value of predictions (i.e., above the

threshold is `true`, below is `false`). If used with a loss function

that sets `from_logits=True` (i.e. no sigmoid applied to predictions),

`thresholds` should be set to 0. One metric value is generated for each

threshold value. If neither thresholds nor top_k are set, the default is

to calculate precision with `thresholds=0.5`.

top_k: (Optional) Unset by default. An int value specifying the top-k

predictions to consider when calculating precision.

class_id: (Optional) Integer class ID for which we want binary metrics.

This must be in the half-open interval `[0, num_classes)`, where

`num_classes` is the last dimension of predictions.

name: (Optional) string name of the metric instance.

dtype: (Optional) data type of the metric result.

Standalone usage:

>>> m = tf.keras.metrics.Precision()

>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])

>>> m.result().numpy()

0.6666667

>>> m.reset_state()

>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])

>>> m.result().numpy()

1.0

>>> # With top_k=2, it will calculate precision over y_true[:2]

>>> # and y_pred[:2]

>>> m = tf.keras.metrics.Precision(top_k=2)

>>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1])

>>> m.result().numpy()

0.0

>>> # With top_k=4, it will calculate precision over y_true[:4]

>>> # and y_pred[:4]

>>> m = tf.keras.metrics.Precision(top_k=4)

>>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1])

>>> m.result().numpy()

0.5

Usage with `compile()` API:

```python

model.compile(optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.Precision()])

```

Usage with a loss with `from_logits=True`:

```python

model.compile(optimizer='adam',

loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

metrics=[tf.keras.metrics.Precision(thresholds=0)])

```

"""

@dtensor_utils.inject_mesh

def __init__(

self, thresholds=None, top_k=None, class_id=None, name=None, dtype=None

):

super().__init__(name=name, dtype=dtype)

self.init_thresholds = thresholds

self.top_k = top_k

self.class_id = class_id

default_threshold = 0.5 if top_k is None else metrics_utils.NEG_INF

self.thresholds = metrics_utils.parse_init_thresholds(

thresholds, default_threshold=default_threshold

)

self._thresholds_distributed_evenly = (

metrics_utils.is_evenly_distributed_thresholds(self.thresholds)

)

self.true_positives = self.add_weight(

"true_positives", shape=(len(self.thresholds),), initializer="zeros"

)

self.false_positives = self.add_weight(

"false_positives",

shape=(len(self.thresholds),),

initializer="zeros",

)

def update_state(self, y_true, y_pred, sample_weight=None):

"""Accumulates 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`.

Returns:

Update op.

"""

return metrics_utils.update_confusion_matrix_variables(

{

metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives, # noqa: E501

metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives, # noqa: E501

},

y_true,

y_pred,

thresholds=self.thresholds,

thresholds_distributed_evenly=self._thresholds_distributed_evenly,

top_k=self.top_k,

class_id=self.class_id,

sample_weight=sample_weight,

)

def result(self):

result = tf.math.divide_no_nan(

self.true_positives,

tf.math.add(self.true_positives, self.false_positives),

)

return result[0] if len(self.thresholds) == 1 else result

def reset_state(self):

num_thresholds = len(to_list(self.thresholds))

backend.batch_set_value(

[

(v, np.zeros((num_thresholds,)))

for v in (self.true_positives, self.false_positives)

]

)

def get_config(self):

config = {

"thresholds": self.init_thresholds,

"top_k": self.top_k,

"class_id": self.class_id,

}

base_config = super().get_config()

return dict(list(base_config.items()) + list(config.items()))

@keras_export("keras.metrics.Recall")

class Recall(base_metric.Metric):

"""Computes the recall of the predictions with respect to the labels.

This metric creates two local variables, `true_positives` and

`false_negatives`, that are used to compute the recall. This value is

ultimately returned as `recall`, an idempotent operation that simply divides

`true_positives` by the sum of `true_positives` and `false_negatives`.

If `sample_weight` is `None`, weights default to 1.

Use `sample_weight` of 0 to mask values.

If `top_k` is set, recall will be computed as how often on average a class

among the labels of a batch entry is in the top-k predictions.

If `class_id` is specified, we calculate recall by considering only the

entries in the batch for which `class_id` is in the label, and computing the

fraction of them for which `class_id` is above the threshold and/or in the

top-k predictions.

Args:

thresholds: (Optional) A float value, or a Python list/tuple of float

threshold values in [0, 1]. A threshold is compared with prediction

values to determine the truth value of predictions (i.e., above the

threshold is `true`, below is `false`). If used with a loss function

that sets `from_logits=True` (i.e. no sigmoid applied to predictions),

`thresholds` should be set to 0. One metric value is generated for each

threshold value. If neither thresholds nor top_k are set, the default is

to calculate recall with `thresholds=0.5`.

top_k: (Optional) Unset by default. An int value specifying the top-k

predictions to consider when calculating recall.

class_id: (Optional) Integer class ID for which we want binary metrics.

This must be in the half-open interval `[0, num_classes)`, where

`num_classes` is the last dimension of predictions.

name: (Optional) string name of the metric instance.

dtype: (Optional) data type of the metric result.

Standalone usage:

>>> m = tf.keras.metrics.Recall()

>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1])

>>> m.result().numpy()

0.6666667

>>> m.reset_state()

>>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0])

>>> m.result().numpy()

1.0

Usage with `compile()` API:

```python

model.compile(optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.Recall()])

```

Usage with a loss with `from_logits=True`:

```python

model.compile(optimizer='adam',

loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

metrics=[tf.keras.metrics.Recall(thresholds=0)])

```

"""

@dtensor_utils.inject_mesh

def __init__(

self, thresholds=None, top_k=None, class_id=None, name=None, dtype=None

):

super().__init__(name=name, dtype=dtype)

self.init_thresholds = thresholds

self.top_k = top_k

self.class_id = class_id

default_threshold = 0.5 if top_k is None else metrics_utils.NEG_INF

self.thresholds = metrics_utils.parse_init_thresholds(

thresholds, default_threshold=default_threshold

)

self._thresholds_distributed_evenly = (

metrics_utils.is_evenly_distributed_thresholds(self.thresholds)

)

self.true_positives = self.add_weight(

"true_positives", shape=(len(self.thresholds),), initializer="zeros"

)

self.false_negatives = self.add_weight(

"false_negatives",

shape=(len(self.thresholds),),

initializer="zeros",

)

def update_state(self, y_true, y_pred, sample_weight=None):

"""Accumulates 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`.

Returns:

Update op.

"""

return metrics_utils.update_confusion_matrix_variables(

{

metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives, # noqa: E501

metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives, # noqa: E501

},

y_true,

y_pred,

thresholds=self.thresholds,

thresholds_distributed_evenly=self._thresholds_distributed_evenly,

top_k=self.top_k,

class_id=self.class_id,

sample_weight=sample_weight,

)

def result(self):

result = tf.math.divide_no_nan(

self.true_positives,

tf.math.add(self.true_positives, self.false_negatives),

)

return result[0] if len(self.thresholds) == 1 else result

def reset_state(self):

num_thresholds = len(to_list(self.thresholds))

backend.batch_set_value(

[

(v, np.zeros((num_thresholds,)))

for v in (self.true_positives, self.false_negatives)

]

)

def get_config(self):

config = {

"thresholds": self.init_thresholds,

"top_k": self.top_k,

"class_id": self.class_id,

}

base_config = super().get_config()

return dict(list(base_config.items()) + list(config.items()))

class SensitivitySpecificityBase(base_metric.Metric, metaclass=abc.ABCMeta):

"""Abstract 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).

"""

def __init__(

self, value, num_thresholds=200, class_id=None, name=None, dtype=None

):

super().__init__(name=name, dtype=dtype)

if num_thresholds <= 0:

raise ValueError(

"Argument `num_thresholds` must be an integer > 0. "

f"Received: num_thresholds={num_thresholds}"

)

self.value = value

self.class_id = class_id

self.true_positives = self.add_weight(

"true_positives", shape=(num_thresholds,), initializer="zeros"

)

self.true_negatives = self.add_weight(

"true_negatives", shape=(num_thresholds,), initializer="zeros"

)

self.false_positives = self.add_weight(

"false_positives", shape=(num_thresholds,), initializer="zeros"

)

self.false_negatives = self.add_weight(

"false_negatives", shape=(num_thresholds,), initializer="zeros"

)

# Compute `num_thresholds` thresholds in [0, 1]

if num_thresholds == 1:

self.thresholds = [0.5]

self._thresholds_distributed_evenly = False

else:

thresholds = [

(i + 1) * 1.0 / (num_thresholds - 1)

for i in range(num_thresholds - 2)

]

self.thresholds = [0.0] + thresholds + [1.0]

self._thresholds_distributed_evenly = True

def update_state(self, y_true, y_pred, sample_weight=None):

"""Accumulates 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`.

Returns:

Update op.

"""

return metrics_utils.update_confusion_matrix_variables(

{

metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives, # noqa: E501

metrics_utils.ConfusionMatrix.TRUE_NEGATIVES: self.true_negatives, # noqa: E501

metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives, # noqa: E501

metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives, # noqa: E501

},

y_true,

y_pred,

thresholds=self.thresholds,

thresholds_distributed_evenly=self._thresholds_distributed_evenly,

class_id=self.class_id,

sample_weight=sample_weight,

)

def reset_state(self):

num_thresholds = len(self.thresholds)

confusion_matrix_variables = (

self.true_positives,

self.true_negatives,

self.false_positives,

self.false_negatives,

)

backend.batch_set_value(

[

(v, np.zeros((num_thresholds,)))

for v in confusion_matrix_variables

]

)

def get_config(self):

config = {"class_id": self.class_id}

base_config = super().get_config()

return dict(list(base_config.items()) + list(config.items()))

def _find_max_under_constraint(self, constrained, dependent, predicate):

"""Returns the maximum of dependent_statistic that satisfies the

constraint.

Args:

constrained: Over these values the constraint

is specified. A rank-1 tensor.

dependent: From these values the maximum that satiesfies the

constraint is selected. Values in this tensor and in

`constrained` are linked by having the same threshold at each

position, hence this tensor must have the same shape.

predicate: A binary boolean functor to be applied to arguments

`constrained` and `self.value`, e.g. `tf.greater`.

Returns:

maximal dependent value, if no value satiesfies the constraint 0.0.

"""

feasible = tf.where(predicate(constrained, self.value))

feasible_exists = tf.greater(tf.size(feasible), 0)

max_dependent = tf.reduce_max(tf.gather(dependent, feasible))

return tf.where(feasible_exists, max_dependent, 0.0)

@keras_export("keras.metrics.SensitivityAtSpecificity")

class SensitivityAtSpecificity(SensitivitySpecificityBase):

"""Computes best sensitivity where specificity is >= specified value.

the sensitivity at a given specificity.

`Sensitivity` measures the proportion of actual positives that are correctly

identified as such (tp / (tp + fn)).

`Specificity` measures the proportion of actual negatives that are correctly

identified as such (tn / (tn + fp)).

This metric creates four local variables, `true_positives`,

`true_negatives`, `false_positives` and `false_negatives` that are used to

compute the sensitivity at the given specificity. The threshold for the

given specificity value is computed and used to evaluate the corresponding

sensitivity.

If `sample_weight` is `None`, weights default to 1.

Use `sample_weight` of 0 to mask values.

If `class_id` is specified, we calculate precision by considering only the

entries in the batch for which `class_id` is above the threshold

predictions, and computing the fraction of them for which `class_id` is

indeed a correct label.

For additional information about specificity and sensitivity, see

[the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity).

Args:

specificity: A scalar value in range `[0, 1]`.

num_thresholds: (Optional) 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.

Standalone usage:

>>> m = tf.keras.metrics.SensitivityAtSpecificity(0.5)

>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])

>>> m.result().numpy()

0.5

>>> m.reset_state()

>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],

... sample_weight=[1, 1, 2, 2, 1])

>>> m.result().numpy()

0.333333

Usage with `compile()` API:

```python

model.compile(

optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.SensitivityAtSpecificity()])

```

"""

@dtensor_utils.inject_mesh

def __init__(

self,

specificity,

num_thresholds=200,

class_id=None,

name=None,

dtype=None,

):

if specificity < 0 or specificity > 1:

raise ValueError(

"Argument `specificity` must be in the range [0, 1]. "

f"Received: specificity={specificity}"

)

self.specificity = specificity

self.num_thresholds = num_thresholds

super().__init__(

specificity,

num_thresholds=num_thresholds,

class_id=class_id,

name=name,

dtype=dtype,

)

def result(self):

specificities = tf.math.divide_no_nan(

self.true_negatives,

tf.math.add(self.true_negatives, self.false_positives),

)

sensitivities = tf.math.divide_no_nan(

self.true_positives,

tf.math.add(self.true_positives, self.false_negatives),

)

return self._find_max_under_constraint(

specificities, sensitivities, tf.greater_equal

)

def get_config(self):

config = {

"num_thresholds": self.num_thresholds,

"specificity": self.specificity,

}

base_config = super().get_config()

return dict(list(base_config.items()) + list(config.items()))

@keras_export("keras.metrics.SpecificityAtSensitivity")

class SpecificityAtSensitivity(SensitivitySpecificityBase):

"""Computes 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.

Standalone usage:

>>> m = tf.keras.metrics.SpecificityAtSensitivity(0.5)

>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8])

>>> m.result().numpy()

0.66666667

>>> m.reset_state()

>>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8],

... sample_weight=[1, 1, 2, 2, 2])

>>> m.result().numpy()

0.5

Usage with `compile()` API:

```python

model.compile(

optimizer='sgd',

loss='mse',

metrics=[tf.keras.metrics.SpecificityAtSensitivity()])

```

"""

@dtensor_utils.inject_mesh

def __init__(

self,

sensitivity,

num_thresholds=200,

class_id=None,

name=None,

dtype=None,

):

if sensitivity < 0 or sensitivity > 1:

raise ValueError(

"Argument `sensitivity` must be in the range [0, 1]. "

f"Received: sensitivity={sensitivity}"

)

self.sensitivity = sensitivity

self.num_thresholds = num_thresholds

super().__init__(

sensitivity,

num_thresholds=num_thresholds,

class_id=class_id,

name=name,

dtype=dtype,

)

def result(self):

sensitivities = tf.math.divide_no_nan(

self.true_positives,

tf.math.add(self.true_positives, self.false_negatives),

)

specificities = tf.math.divide_no_nan(

self.true_negatives,

tf.math.add(self.true_negatives, self.false_positives),

)

return self._find_max_under_constraint(

sensitivities, specificities, tf.greater_equal

)

def get_config(self):

config = {

"num_thresholds": self.num_thresholds,

"sensitivity": self.sensitivity,

}

base_config = super().get_config()

return dict(list(base_config.items()) + list(config.items()))

@keras_export("keras.metrics.PrecisionAtRecall")

class PrecisionAtRecall(SensitivitySpecificityBase):

"""Computes 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: