ratspub: remove definitions as they are replaced by genecup

1 files changed, 0 insertions, 1133 deletions

diff --git a/keras-auc-optimizer.patch b/keras-auc-optimizer.patch
deleted file mode 100644
index bbc6924..0000000
--- a/keras-auc-optimizer.patch
+++ /dev/null
@@ -1,1133 +0,0 @@
-From 901159da45695da24a5206125910f02fc50169ce Mon Sep 17 00:00:00 2001
-From: Efraim Flashner <efraim@flashner.co.il>
-Date: Thu, 23 Apr 2020 15:50:37 +0300
-Subject: [PATCH] add keras metrics
-
----
- keras/backend/tensorflow_backend.py |  12 +
- keras/metrics.py                    | 584 ++++++++++++++++++++++++++++
- keras/utils/__init__.py             |   2 +
- keras/utils/losses_utils.py         | 177 +++++++++
- keras/utils/metrics_utils.py        | 278 +++++++++++++
- 5 files changed, 1053 insertions(+)
- create mode 100644 keras/utils/losses_utils.py
- create mode 100644 keras/utils/metrics_utils.py
-
-diff --git a/keras/backend/tensorflow_backend.py b/keras/backend/tensorflow_backend.py
-index bcb8be0..a2870f5 100644
---- a/keras/backend/tensorflow_backend.py
-+++ b/keras/backend/tensorflow_backend.py
-@@ -4453,3 +4453,15 @@ def local_conv2d(inputs, kernel, kernel_size, strides, output_shape, data_format
-     else:
-         output = permute_dimensions(output, (2, 0, 1, 3))
-     return output
-+
-+#get_graph = tf_keras_backend.get_graph
-+
-+#def is_symbolic(x):
-+#    return isinstance(x, tf.Tensor) and hasattr(x, 'op')
-+
-+def size(x, name=None):
-+#    if is_symbolic(x):
-+#        with get_graph().as_default():
-+#            return tf.size(x)
-+    return tf.size(x, name=name)
-+
-diff --git a/keras/metrics.py b/keras/metrics.py
-index 8e3df1f..8f57910 100644
---- a/keras/metrics.py
-+++ b/keras/metrics.py
-@@ -4,8 +4,12 @@ from __future__ import absolute_import
- from __future__ import division
- from __future__ import print_function
- 
-+import abc
- import six
-+import types
-+
- from . import backend as K
-+from .engine.base_layer import Layer
- from .losses import mean_squared_error
- from .losses import mean_absolute_error
- from .losses import mean_absolute_percentage_error
-@@ -19,10 +23,201 @@ from .losses import binary_crossentropy
- from .losses import kullback_leibler_divergence
- from .losses import poisson
- from .losses import cosine_proximity
-+from .utils import losses_utils
-+from .utils import metrics_utils
- from .utils.generic_utils import deserialize_keras_object
- from .utils.generic_utils import serialize_keras_object
- 
- 
-+@six.add_metaclass(abc.ABCMeta)
-+class Metric(Layer):
-+    """Encapsulates metric logic and state.
-+
-+    Standalone usage:
-+    ```python
-+    m = SomeMetric(...)
-+    for input in ...:
-+        m.update_state(input)
-+    m.result()
-+    ```
-+
-+    Usage with the `compile` API:
-+    ```python
-+    model.compile(optimizer='rmsprop',
-+                  loss=keras.losses.categorical_crossentropy,
-+                  metrics=[keras.metrics.CategoricalAccuracy()])
-+    ```
-+
-+    To be implemented by subclasses:
-+    * `__init__()`: All state variables should be created in this method by
-+        calling `self.add_weight()` like: `self.var = self.add_weight(...)`
-+    * `update_state()`: Has all updates to the state variables like:
-+        self.var.assign_add(...).
-+    * `result()`: Computes and returns a value for the metric
-+        from the state variables.
-+    """
-+
-+    def __init__(self, name=None, dtype=None, **kwargs):
-+        super(Metric, self).__init__(name=name, dtype=dtype, **kwargs)
-+        self.stateful = True  # All metric layers are stateful.
-+        self.built = True
-+        self.dtype = K.floatx() if dtype is None else dtype
-+
-+    def __new__(cls, *args, **kwargs):
-+        obj = super(Metric, cls).__new__(cls)
-+        update_state_fn = obj.update_state
-+
-+        obj.update_state = types.MethodType(
-+            metrics_utils.update_state_wrapper(update_state_fn), obj)
-+        return obj
-+
-+    def __call__(self, *args, **kwargs):
-+        """Accumulates statistics and then computes metric result value."""
-+        update_op = self.update_state(*args, **kwargs)
-+        return self.result()
-+
-+    def get_config(self):
-+        """Returns the serializable config of the metric."""
-+        return {'name': self.name, 'dtype': self.dtype}
-+
-+    def reset_states(self):
-+        """Resets all of the metric state variables.
-+        This function is called between epochs/steps,
-+        when a metric is evaluated during training.
-+        """
-+        K.batch_set_value([(v, 0) for v in self.weights])
-+
-+    @abc.abstractmethod
-+    def update_state(self, *args, **kwargs):
-+        """Accumulates statistics for the metric. """
-+        raise NotImplementedError('Must be implemented in subclasses.')
-+
-+    @abc.abstractmethod
-+    def result(self):
-+        """Computes and returns the metric value tensor.
-+        Result computation is an idempotent operation that simply calculates the
-+        metric value using the state variables.
-+        """
-+        raise NotImplementedError('Must be implemented in subclasses.')
-+
-+    # For use by subclasses #
-+    def add_weight(self,
-+                   name,
-+                   shape=(),
-+                   initializer=None,
-+                   dtype=None):
-+        """Adds state variable. Only for use by subclasses."""
-+        return super(Metric, self).add_weight(
-+            name=name,
-+            shape=shape,
-+            dtype=self.dtype if dtype is None else dtype,
-+            trainable=False,
-+            initializer=initializer)
-+
-+    # End: For use by subclasses ###
-+
-+
-+class Reduce(Metric):
-+    """Encapsulates metrics that perform a reduce operation on the values."""
-+
-+    def __init__(self, reduction, name, dtype=None):
-+        """Creates a `Reduce` instance.
-+        # Arguments
-+            reduction: a metrics `Reduction` enum value.
-+            name: string name of the metric instance.
-+            dtype: (Optional) data type of the metric result.
-+        """
-+        super(Reduce, self).__init__(name=name, dtype=dtype)
-+        self.reduction = reduction
-+        self.total = self.add_weight('total', initializer='zeros')
-+        if reduction in [metrics_utils.Reduction.SUM_OVER_BATCH_SIZE,
-+                         metrics_utils.Reduction.WEIGHTED_MEAN]:
-+            self.count = self.add_weight('count', initializer='zeros')
-+
-+    def update_state(self, values, sample_weight=None):
-+        """Accumulates statistics for computing the reduction metric.
-+        For example, if `values` is [1, 3, 5, 7] and reduction=SUM_OVER_BATCH_SIZE,
-+        then the value of `result()` is 4. If the `sample_weight` is specified as
-+        [1, 1, 0, 0] then value of `result()` would be 2.
-+        # Arguments
-+            values: Per-example value.
-+            sample_weight: Optional weighting of each example. Defaults to 1.
-+        """
-+        values = K.cast(values, self.dtype)
-+        if sample_weight is not None:
-+            sample_weight = K.cast(sample_weight, self.dtype)
-+            # Update dimensions of weights to match with values if possible.
-+            values, _, sample_weight = losses_utils.squeeze_or_expand_dimensions(
-+                values, sample_weight=sample_weight)
-+
-+            # Broadcast weights if possible.
-+            sample_weight = losses_utils.broadcast_weights(sample_weight, values)
-+            values = values * sample_weight
-+
-+        value_sum = K.sum(values)
-+        update_total_op = K.update_add(self.total, value_sum)
-+
-+        # Exit early if the reduction doesn't have a denominator.
-+        if self.reduction == metrics_utils.Reduction.SUM:
-+            return update_total_op
-+
-+        # Update `count` for reductions that require a denominator.
-+        if self.reduction == metrics_utils.Reduction.SUM_OVER_BATCH_SIZE:
-+            num_values = K.cast(K.size(values), self.dtype)
-+        elif self.reduction == metrics_utils.Reduction.WEIGHTED_MEAN:
-+            if sample_weight is None:
-+                num_values = K.cast(K.size(values), self.dtype)
-+            else:
-+                num_values = K.sum(sample_weight)
-+        else:
-+            raise NotImplementedError(
-+                'reduction [%s] not implemented' % self.reduction)
-+
-+        with K.control_dependencies([update_total_op]):
-+            return K.update_add(self.count, num_values)
-+
-+    def result(self):
-+        if self.reduction == metrics_utils.Reduction.SUM:
-+            return self.total
-+        elif self.reduction in [
-+            metrics_utils.Reduction.WEIGHTED_MEAN,
-+            metrics_utils.Reduction.SUM_OVER_BATCH_SIZE
-+        ]:
-+            return self.total / self.count
-+        else:
-+            raise NotImplementedError(
-+                'reduction [%s] not implemented' % self.reduction)
-+
-+
-+class Sum(Reduce):
-+    """Computes the (weighted) sum of the given values.
-+
-+    For example, if values is [1, 3, 5, 7] then the sum is 16.
-+    If the weights were specified as [1, 1, 0, 0] then the sum would be 4.
-+
-+    This metric creates one variable, `total`, that is used to compute the sum of
-+    `values`. This is ultimately returned as `sum`.
-+    If `sample_weight` is `None`, weights default to 1.  Use `sample_weight` of 0
-+    to mask values.
-+
-+    Standalone usage:
-+    ```python
-+    m = keras.metrics.Sum()
-+    m.update_state([1, 3, 5, 7])
-+    m.result()
-+    ```
-+    """
-+
-+    def __init__(self, name='sum', dtype=None):
-+        """Creates a `Sum` instance.
-+        # Arguments
-+            name: (Optional) string name of the metric instance.
-+            dtype: (Optional) data type of the metric result.
-+        """
-+        super(Sum, self).__init__(reduction=metrics_utils.Reduction.SUM,
-+                                  name=name, dtype=dtype)
-+
-+
- def binary_accuracy(y_true, y_pred):
-     return K.mean(K.equal(y_true, K.round(y_pred)), axis=-1)
- 
-@@ -49,6 +244,395 @@ def sparse_top_k_categorical_accuracy(y_true, y_pred, k=5):
-     return K.mean(K.in_top_k(y_pred, K.cast(K.flatten(y_true), 'int32'), k),
-                   axis=-1)
- 
-+class SensitivitySpecificityBase(Metric):
-+    """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, name=None, dtype=None):
-+        super(SensitivitySpecificityBase, self).__init__(name=name, dtype=dtype)
-+        if num_thresholds <= 0:
-+            raise ValueError('`num_thresholds` must be > 0.')
-+        self.value = value
-+        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]
-+        else:
-+            thresholds = [(i + 1) * 1.0 / (num_thresholds - 1)
-+                          for i in range(num_thresholds - 2)]
-+            self.thresholds = [0.0] + thresholds + [1.0]
-+
-+    def update_state(self, y_true, y_pred, sample_weight=None):
-+        return metrics_utils.update_confusion_matrix_variables(
-+            {
-+                metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives,
-+                metrics_utils.ConfusionMatrix.TRUE_NEGATIVES: self.true_negatives,
-+                metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives,
-+                metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives,
-+            },
-+            y_true,
-+            y_pred,
-+            thresholds=self.thresholds,
-+            sample_weight=sample_weight)
-+
-+    def reset_states(self):
-+        num_thresholds = len(self.thresholds)
-+        K.batch_set_value(
-+            [(v, np.zeros((num_thresholds,))) for v in self.variables])
-+
-+
-+class SensitivityAtSpecificity(SensitivitySpecificityBase):
-+    """Computes 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.
-+
-+    For additional information about specificity and sensitivity, see the
-+    following: https://en.wikipedia.org/wiki/Sensitivity_and_specificity
-+
-+    Usage with the compile API:
-+
-+    ```python
-+    model = keras.Model(inputs, outputs)
-+    model.compile(
-+        'sgd',
-+        loss='mse',
-+        metrics=[keras.metrics.SensitivityAtSpecificity()])
-+    ```
-+
-+    # Arguments
-+        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.
-+        name: (Optional) string name of the metric instance.
-+        dtype: (Optional) data type of the metric result.
-+    """
-+
-+    def __init__(self, specificity, num_thresholds=200, name=None, dtype=None):
-+        if specificity < 0 or specificity > 1:
-+            raise ValueError('`specificity` must be in the range [0, 1].')
-+        self.specificity = specificity
-+        self.num_thresholds = num_thresholds
-+        super(SensitivityAtSpecificity, self).__init__(
-+            specificity, num_thresholds=num_thresholds, name=name, dtype=dtype)
-+
-+    def result(self):
-+        # Calculate specificities at all the thresholds.
-+        specificities = K.switch(
-+            K.greater(self.true_negatives + self.false_positives, 0),
-+            (self.true_negatives / (self.true_negatives + self.false_positives)),
-+            K.zeros_like(self.thresholds))
-+
-+        # Find the index of the threshold where the specificity is closest to the
-+        # given specificity.
-+        min_index = K.argmin(
-+            K.abs(specificities - self.value), axis=0)
-+        min_index = K.cast(min_index, 'int32')
-+
-+        # Compute sensitivity at that index.
-+        return K.switch(
-+            K.greater((self.true_positives[min_index] +
-+                       self.false_negatives[min_index]), 0),
-+            (self.true_positives[min_index] /
-+                (self.true_positives[min_index] + self.false_negatives[min_index])),
-+            K.zeros_like(self.true_positives[min_index]))
-+
-+    def get_config(self):
-+        config = {
-+            'num_thresholds': self.num_thresholds,
-+            'specificity': self.specificity
-+        }
-+        base_config = super(SensitivityAtSpecificity, self).get_config()
-+        return dict(list(base_config.items()) + list(config.items()))
-+
-+
-+class AUC(Metric):
-+    """Computes the approximate AUC (Area under the curve) via a Riemann sum.
-+
-+    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 best results, `predictions` should be distributed approximately uniformly
-+    in the range [0, 1] and not peaked around 0 or 1. 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.
-+
-+    Usage with the compile API:
-+
-+    ```python
-+    model = keras.Model(inputs, outputs)
-+    model.compile('sgd', loss='mse', metrics=[keras.metrics.AUC()])
-+    ```
-+
-+    # Arguments
-+        num_thresholds: (Optional) Defaults to 200. The number of thresholds to
-+            use when discretizing the roc curve. Values must be > 1.
-+            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 used
-+            (https://en.wikipedia.org/wiki/Riemann_sum): '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' that applies left summation
-+              for increasing intervals and right summation for decreasing intervals;
-+              'majoring' that 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.
-+    """
-+
-+    def __init__(self,
-+                 num_thresholds=200,
-+                 curve='ROC',
-+                 summation_method='interpolation',
-+                 name=None,
-+                 dtype=None,
-+                 thresholds=None):
-+        # Validate configurations.
-+        if (isinstance(curve, metrics_utils.AUCCurve) and
-+                curve not in list(metrics_utils.AUCCurve)):
-+            raise ValueError('Invalid curve: "{}". Valid options are: "{}"'.format(
-+                curve, list(metrics_utils.AUCCurve)))
-+        if isinstance(
-+            summation_method,
-+            metrics_utils.AUCSummationMethod) and summation_method not in list(
-+                metrics_utils.AUCSummationMethod):
-+            raise ValueError(
-+                'Invalid summation method: "{}". Valid options are: "{}"'.format(
-+                    summation_method, list(metrics_utils.AUCSummationMethod)))
-+
-+        # Update properties.
-+        if thresholds is not None:
-+            # If specified, use the supplied thresholds.
-+            self.num_thresholds = len(thresholds) + 2
-+            thresholds = sorted(thresholds)
-+        else:
-+            if num_thresholds <= 1:
-+                raise ValueError('`num_thresholds` must be > 1.')
-+
-+            # Otherwise, linearly interpolate (num_thresholds - 2) thresholds in
-+            # (0, 1).
-+            self.num_thresholds = num_thresholds
-+            thresholds = [(i + 1) * 1.0 / (num_thresholds - 1)
-+                          for i in range(num_thresholds - 2)]
-+
-+        # Add an endpoint "threshold" below zero and above one for either
-+        # threshold method to account for floating point imprecisions.
-+        self.thresholds = [0.0 - K.epsilon()] + thresholds + [1.0 + K.epsilon()]
-+
-+        if isinstance(curve, metrics_utils.AUCCurve):
-+            self.curve = curve
-+        else:
-+            self.curve = metrics_utils.AUCCurve.from_str(curve)
-+        if isinstance(summation_method, metrics_utils.AUCSummationMethod):
-+            self.summation_method = summation_method
-+        else:
-+            self.summation_method = metrics_utils.AUCSummationMethod.from_str(
-+                summation_method)
-+        super(AUC, self).__init__(name=name, dtype=dtype)
-+
-+        # Create metric variables
-+        self.true_positives = self.add_weight(
-+            'true_positives',
-+            shape=(self.num_thresholds,),
-+            initializer='zeros')
-+        self.true_negatives = self.add_weight(
-+            'true_negatives',
-+            shape=(self.num_thresholds,),
-+            initializer='zeros')
-+        self.false_positives = self.add_weight(
-+            'false_positives',
-+            shape=(self.num_thresholds,),
-+            initializer='zeros')
-+        self.false_negatives = self.add_weight(
-+            'false_negatives',
-+            shape=(self.num_thresholds,),
-+            initializer='zeros')
-+
-+    def update_state(self, y_true, y_pred, sample_weight=None):
-+        return metrics_utils.update_confusion_matrix_variables({
-+            metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives,
-+            metrics_utils.ConfusionMatrix.TRUE_NEGATIVES: self.true_negatives,
-+            metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives,
-+            metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives,
-+        }, y_true, y_pred, self.thresholds, sample_weight=sample_weight)
-+
-+    def interpolate_pr_auc(self):
-+        """Interpolation 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.
-+        """
-+        dtp = self.true_positives[:self.num_thresholds -
-+                                  1] - self.true_positives[1:]
-+        p = self.true_positives + self.false_positives
-+        dp = p[:self.num_thresholds - 1] - p[1:]
-+
-+        prec_slope = dtp / K.maximum(dp, 0)
-+        intercept = self.true_positives[1:] - (prec_slope * p[1:])
-+
-+        # Logical and
-+        pMin = K.expand_dims(p[:self.num_thresholds - 1] > 0, 0)
-+        pMax = K.expand_dims(p[1:] > 0, 0)
-+        are_different = K.concatenate([pMin, pMax], axis=0)
-+        switch_condition = K.all(are_different, axis=0)
-+
-+        safe_p_ratio = K.switch(
-+            switch_condition,
-+            p[:self.num_thresholds - 1] / K.maximum(p[1:], 0),
-+            K.ones_like(p[1:]))
-+
-+        numer = prec_slope * (dtp + intercept * K.log(safe_p_ratio))
-+        denom = K.maximum(self.true_positives[1:] + self.false_negatives[1:], 0)
-+        return K.sum((numer / denom))
-+
-+    def result(self):
-+        if (self.curve == metrics_utils.AUCCurve.PR and
-+                (self.summation_method ==
-+                 metrics_utils.AUCSummationMethod.INTERPOLATION)):
-+            # This use case is different and is handled separately.
-+            return self.interpolate_pr_auc()
-+
-+        # Set `x` and `y` values for the curves based on `curve` config.
-+        recall = K.switch(
-+            K.greater((self.true_positives), 0),
-+            (self.true_positives /
-+                (self.true_positives + self.false_negatives)),
-+            K.zeros_like(self.true_positives))
-+        if self.curve == metrics_utils.AUCCurve.ROC:
-+            fp_rate = K.switch(
-+                K.greater((self.false_positives), 0),
-+                (self.false_positives /
-+                    (self.false_positives + self.true_negatives)),
-+                K.zeros_like(self.false_positives))
-+            x = fp_rate
-+            y = recall
-+        else:  # curve == 'PR'.
-+            precision = K.switch(
-+                K.greater((self.true_positives), 0),
-+                (self.true_positives / (self.true_positives + self.false_positives)),
-+                K.zeros_like(self.true_positives))
-+            x = recall
-+            y = precision
-+
-+        # Find the rectangle heights based on `summation_method`.
-+        if self.summation_method == metrics_utils.AUCSummationMethod.INTERPOLATION:
-+            # Note: the case ('PR', 'interpolation') has been handled above.
-+            heights = (y[:self.num_thresholds - 1] + y[1:]) / 2.
-+        elif self.summation_method == metrics_utils.AUCSummationMethod.MINORING:
-+            heights = K.minimum(y[:self.num_thresholds - 1], y[1:])
-+        else:  # self.summation_method = metrics_utils.AUCSummationMethod.MAJORING:
-+            heights = K.maximum(y[:self.num_thresholds - 1], y[1:])
-+
-+        # Sum up the areas of all the rectangles.
-+        return K.sum((x[:self.num_thresholds - 1] - x[1:]) * heights)
-+
-+    def reset_states(self):
-+        K.batch_set_value(
-+            [(v, np.zeros((self.num_thresholds,))) for v in self.variables])
-+
-+    def get_config(self):
-+        config = {
-+            'num_thresholds': self.num_thresholds,
-+            'curve': self.curve.value,
-+            'summation_method': self.summation_method.value,
-+            # We remove the endpoint thresholds as an inverse of how the thresholds
-+            # were initialized. This ensures that a metric initialized from this
-+            # config has the same thresholds.
-+            'thresholds': self.thresholds[1:-1],
-+        }
-+        base_config = super(AUC, self).get_config()
-+        return dict(list(base_config.items()) + list(config.items()))
-+
- 
- # Aliases
- 
-diff --git a/keras/utils/__init__.py b/keras/utils/__init__.py
-index 8cc39d5..65af329 100644
---- a/keras/utils/__init__.py
-+++ b/keras/utils/__init__.py
-@@ -4,6 +4,8 @@ from . import generic_utils
- from . import data_utils
- from . import io_utils
- from . import conv_utils
-+from . import losses_utils
-+from . import metrics_utils
- 
- # Globally-importable utils.
- from .io_utils import HDF5Matrix
-diff --git a/keras/utils/losses_utils.py b/keras/utils/losses_utils.py
-new file mode 100644
-index 0000000..617ebb7
---- /dev/null
-+++ b/keras/utils/losses_utils.py
-@@ -0,0 +1,177 @@
-+"""Utilities related to losses."""
-+from __future__ import absolute_import
-+from __future__ import division
-+from __future__ import print_function
-+
-+import numpy as np
-+
-+from .. import backend as K
-+
-+
-+class Reduction(object):
-+    """Types of loss reduction.
-+
-+    Contains the following values:
-+
-+    * `NONE`: Un-reduced weighted losses with the same shape as input. When this
-+        reduction type used with built-in Keras training loops like
-+        `fit`/`evaluate`, the unreduced vector loss is passed to the optimizer but
-+        the reported loss will be a scalar value.
-+    * `SUM`: Scalar sum of weighted losses.
-+    * `SUM_OVER_BATCH_SIZE`: Scalar `SUM` divided by number of elements in losses.
-+    """
-+
-+    NONE = 'none'
-+    SUM = 'sum'
-+    SUM_OVER_BATCH_SIZE = 'sum_over_batch_size'
-+
-+    @classmethod
-+    def all(cls):
-+        return (cls.NONE, cls.SUM, cls.SUM_OVER_BATCH_SIZE)
-+
-+    @classmethod
-+    def validate(cls, key):
-+        if key not in cls.all():
-+            raise ValueError('Invalid Reduction Key %s.' % key)
-+
-+
-+def squeeze_or_expand_dimensions(y_pred, y_true=None, sample_weight=None):
-+    """Squeeze or expand last dimension if needed.
-+
-+    1. Squeezes last dim of `y_pred` or `y_true` if their rank differs by 1.
-+    2. Squeezes or expands last dim of `sample_weight` if its rank differs by 1
-+    from the new rank of `y_pred`.
-+    If `sample_weight` is scalar, it is kept scalar.
-+
-+    # Arguments
-+    y_pred: Predicted values, a `Tensor` of arbitrary dimensions.
-+    y_true: Optional label `Tensor` whose dimensions match `y_pred`.
-+    sample_weight: Optional weight scalar or `Tensor` whose dimensions match
-+    `y_pred`.
-+
-+    # Returns
-+    Tuple of `y_pred`, `y_true` and `sample_weight`. Each of them possibly has
-+    the last dimension squeezed, `sample_weight` could be extended by one
-+    dimension.
-+    """
-+    if y_true is not None:
-+        y_pred_rank = K.ndim(y_pred)
-+        y_pred_shape = K.int_shape(y_pred)
-+        y_true_rank = K.ndim(y_true)
-+        y_true_shape = K.int_shape(y_true)
-+
-+        if (y_pred_rank - y_true_rank == 1) and (y_pred_shape[-1] == 1):
-+            y_pred = K.squeeze(y_pred, -1)
-+        elif (y_true_rank - y_pred_rank == 1) and (y_true_shape[-1] == 1):
-+            y_true = K.squeeze(y_true, -1)
-+
-+    if sample_weight is None:
-+        return y_pred, y_true
-+
-+    y_pred_rank = K.ndim(y_pred)
-+    weights_rank = K.ndim(sample_weight)
-+    if weights_rank != 0:
-+        if weights_rank - y_pred_rank == 1:
-+            sample_weight = K.squeeze(sample_weight, -1)
-+        elif y_pred_rank - weights_rank == 1:
-+           sample_weight = K.expand_dims(sample_weight, -1)
-+    return y_pred, y_true, sample_weight
-+
-+
-+def _num_elements(losses):
-+    """Computes the number of elements in `losses` tensor."""
-+    with K.name_scope('num_elements') as scope:
-+        return K.cast(K.size(losses, name=scope), losses.dtype)
-+
-+
-+def reduce_weighted_loss(weighted_losses, reduction=Reduction.SUM_OVER_BATCH_SIZE):
-+    """Reduces the individual weighted loss measurements."""
-+    if reduction == Reduction.NONE:
-+        loss = weighted_losses
-+    else:
-+        loss = K.sum(weighted_losses)
-+        if reduction == Reduction.SUM_OVER_BATCH_SIZE:
-+            loss = loss / _num_elements(weighted_losses)
-+    return loss
-+
-+
-+def broadcast_weights(values, sample_weight):
-+    # Broadcast weights if possible.
-+    weights_shape = K.int_shape(sample_weight)
-+    values_shape = K.int_shape(values)
-+
-+    if values_shape != weights_shape:
-+        weights_rank = K.ndim(sample_weight)
-+        values_rank = K.ndim(values)
-+
-+        # Raise error if ndim of weights is > values.
-+        if weights_rank > values_rank:
-+            raise ValueError(
-+                'Incompatible shapes: `values` {} vs `sample_weight` {}'.format(
-+                    values_shape, weights_shape))
-+
-+        # Expand dim of weights to match ndim of values, if required.
-+            for i in range(weights_rank, values_rank):
-+                sample_weight = K.expand_dims(sample_weight, axis=i)
-+
-+        if weights_shape is not None and values_shape is not None:
-+            for i in range(weights_rank):
-+                if (weights_shape[i] is not None and
-+                   values_shape[i] is not None and
-+                       weights_shape[i] != values_shape[i]):
-+                   # Cannot be broadcasted.
-+                   if weights_shape[i] != 1:
-+                       raise ValueError(
-+                           'Incompatible shapes: `values` {} vs '
-+                           '`sample_weight` {}'.format(
-+                               values_shape, weights_shape))
-+                   sample_weight = K.repeat_elements(
-+                       sample_weight, values_shape[i], axis=i)
-+    return sample_weight
-+
-+
-+def compute_weighted_loss(losses,
-+                          sample_weight=None,
-+                          reduction=Reduction.SUM_OVER_BATCH_SIZE,
-+                          name=None):
-+    """Computes the weighted loss.
-+
-+    # Arguments
-+        losses: `Tensor` of shape `[batch_size, d1, ... dN]`.
-+        sample_weight: Optional `Tensor` whose rank is either 0, or the same rank as
-+        `   losses`, or be broadcastable to `losses`.
-+        reduction: (Optional) Type of Reduction to apply to loss.
-+            Default value is `SUM_OVER_BATCH_SIZE`.
-+        name: Optional name for the op.
-+
-+    # Raises
-+        ValueError: If the shape of `sample_weight` is not compatible with `losses`.
-+
-+    # Returns
-+        Weighted loss `Tensor` of the same type as `losses`. If `reduction` is
-+            `NONE`, this has the same shape as `losses`; otherwise, it is scalar.
-+    """
-+    Reduction.validate(reduction)
-+    if sample_weight is None:
-+        sample_weight = 1.0
-+    with K.name_scope(name or 'weighted_loss'):
-+        input_dtype = K.dtype(losses)
-+        losses = K.cast(losses, K.floatx())
-+        sample_weight = K.cast(sample_weight, K.floatx())
-+
-+        # Update dimensions of `sample_weight` to match with `losses` if possible.
-+        losses, _, sample_weight = squeeze_or_expand_dimensions(
-+            losses, None, sample_weight)
-+
-+        # Broadcast weights if possible.
-+        sample_weight = broadcast_weights(losses, sample_weight)
-+
-+        # Apply weights to losses.
-+        weighted_losses = sample_weight * losses
-+
-+        # Apply reduction function to the individual weighted losses.
-+        loss = reduce_weighted_loss(weighted_losses, reduction)
-+        # Convert the result back to the input type.
-+        loss = K.cast(loss, input_dtype)
-+        return loss
-+
-diff --git a/keras/utils/metrics_utils.py b/keras/utils/metrics_utils.py
-new file mode 100644
-index 0000000..e6a5bb0
---- /dev/null
-+++ b/keras/utils/metrics_utils.py
-@@ -0,0 +1,278 @@
-+"""Utilities related to metrics."""
-+from __future__ import absolute_import
-+from __future__ import division
-+from __future__ import print_function
-+
-+from enum import Enum
-+
-+from .. import backend as K
-+from . import losses_utils
-+
-+NEG_INF = -1e10
-+
-+class Reduction(object):
-+    """Types of metrics reduction.
-+    Contains the following values:
-+    * `SUM`: Scalar sum of weighted values.
-+    * `SUM_OVER_BATCH_SIZE`: Scalar `SUM` of weighted values divided by
-+        number of elements in values.
-+    * `WEIGHTED_MEAN`: Scalar sum of weighted values divided by sum of weights.
-+    """
-+
-+    SUM = 'sum'
-+    SUM_OVER_BATCH_SIZE = 'sum_over_batch_size'
-+    WEIGHTED_MEAN = 'weighted_mean'
-+
-+
-+def update_state_wrapper(update_state_fn):
-+    """Decorator to wrap metric `update_state()` with `add_update()`.
-+    # Arguments
-+        update_state_fn: function that accumulates metric statistics.
-+    # Returns
-+        Decorated function that wraps `update_state_fn()` with `add_update()`.
-+    """
-+    def decorated(metric_obj, *args, **kwargs):
-+        """Decorated function with `add_update()`."""
-+
-+        update_op = update_state_fn(*args, **kwargs)
-+        metric_obj.add_update(update_op)
-+        return update_op
-+
-+    return decorated
-+
-+def result_wrapper(result_fn):
-+    """Decorator to wrap metric `result()` with identity op.
-+    Wrapping result in identity so that control dependency between
-+    update_op from `update_state` and result works in case result returns
-+    a tensor.
-+    # Arguments
-+        result_fn: function that computes the metric result.
-+    # Returns
-+        Decorated function that wraps `result()` with identity op.
-+    """
-+    def decorated(metric_obj, *args, **kwargs):
-+        result_t = K.identity(result_fn(*args, **kwargs))
-+        metric_obj._call_result = result_t
-+        result_t._is_metric = True
-+        return result_t
-+    return decorated
-+
-+
-+def to_list(x):
-+    if isinstance(x, list):
-+        return x
-+    return [x]
-+
-+
-+def assert_thresholds_range(thresholds):
-+    if thresholds is not None:
-+        invalid_thresholds = [t for t in thresholds if t is None or t < 0 or t > 1]
-+    if invalid_thresholds:
-+        raise ValueError(
-+            'Threshold values must be in [0, 1]. Invalid values: {}'.format(
-+            invalid_thresholds))
-+
-+
-+def parse_init_thresholds(thresholds, default_threshold=0.5):
-+    if thresholds is not None:
-+        assert_thresholds_range(to_list(thresholds))
-+    thresholds = to_list(default_threshold if thresholds is None else thresholds)
-+    return thresholds
-+
-+class ConfusionMatrix(Enum):
-+    TRUE_POSITIVES = 'tp'
-+    FALSE_POSITIVES = 'fp'
-+    TRUE_NEGATIVES = 'tn'
-+    FALSE_NEGATIVES = 'fn'
-+
-+class AUCCurve(Enum):
-+    """Type of AUC Curve (ROC or PR)."""
-+    ROC = 'ROC'
-+    PR = 'PR'
-+
-+    @staticmethod
-+    def from_str(key):
-+        if key in ('pr', 'PR'):
-+            return AUCCurve.PR
-+        elif key in ('roc', 'ROC'):
-+            return AUCCurve.ROC
-+        else:
-+            raise ValueError('Invalid AUC curve value "%s".' % key)
-+
-+
-+class AUCSummationMethod(Enum):
-+    """Type of AUC summation method.
-+
-+    https://en.wikipedia.org/wiki/Riemann_sum)
-+
-+    Contains the following values:
-+    * 'interpolation': Applies mid-point summation scheme for `ROC` curve. For
-+    `PR` curve, 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': Applies right summation for increasing intervals and left
-+    summation for decreasing intervals.
-+    """
-+    INTERPOLATION = 'interpolation'
-+    MAJORING = 'majoring'
-+    MINORING = 'minoring'
-+
-+    @staticmethod
-+    def from_str(key):
-+        if key in ('interpolation', 'Interpolation'):
-+            return AUCSummationMethod.INTERPOLATION
-+        elif key in ('majoring', 'Majoring'):
-+            return AUCSummationMethod.MAJORING
-+        elif key in ('minoring', 'Minoring'):
-+            return AUCSummationMethod.MINORING
-+        else:
-+            raise ValueError('Invalid AUC summation method value "%s".' % key)
-+
-+def weighted_assign_add(label, pred, weights, var):
-+    # Logical and
-+    label = K.expand_dims(label, 0)
-+    pred = K.expand_dims(pred, 0)
-+    are_different = K.concatenate([label, pred], axis=0)
-+    label_and_pred = K.all(are_different, axis=0)
-+    label_and_pred = K.cast(label_and_pred, dtype=K.floatx())
-+    if weights is not None:
-+        label_and_pred *= weights
-+    return var.assign_add(K.sum(label_and_pred, 1))
-+
-+def update_confusion_matrix_variables(variables_to_update,
-+                                      y_true,
-+                                      y_pred,
-+                                      thresholds,
-+                                      top_k=None,
-+                                      class_id=None,
-+                                      sample_weight=None):
-+    """Returns op to update the given confusion matrix variables.
-+    For every pair of values in y_true and y_pred:
-+    true_positive: y_true == True and y_pred > thresholds
-+    false_negatives: y_true == True and y_pred <= thresholds
-+    true_negatives: y_true == False and y_pred <= thresholds
-+    false_positive: y_true == False and y_pred > thresholds
-+    The results will be weighted and added together. When multiple thresholds are
-+    provided, we will repeat the same for every threshold.
-+    For estimation of these metrics over a stream of data, the function creates an
-+    `update_op` operation that updates the given variables.
-+    If `sample_weight` is `None`, weights default to 1.
-+    Use weights of 0 to mask values.
-+    # Arguments
-+    variables_to_update: Dictionary with 'tp', 'fn', 'tn', 'fp' as valid keys
-+      and corresponding variables to update as values.
-+    y_true: A `Tensor` whose shape matches `y_pred`. Will be cast to `bool`.
-+    y_pred: A floating point `Tensor` of arbitrary shape and whose values are in
-+      the range `[0, 1]`.
-+    thresholds: A float value or a python list or tuple of float thresholds in
-+      `[0, 1]`, or NEG_INF (used when top_k is set).
-+    top_k: Optional int, indicates that the positive labels should be limited to
-+      the top k predictions.
-+    class_id: Optional int, limits the prediction and labels to the class
-+      specified by this argument.
-+    sample_weight: Optional `Tensor` whose rank is either 0, or the same rank as
-+      `y_true`, and must be broadcastable to `y_true` (i.e., all dimensions must
-+      be either `1`, or the same as the corresponding `y_true` dimension).
-+    # Returns
-+        Update ops.
-+    # Raises
-+        ValueError: If `y_pred` and `y_true` have mismatched shapes, or if
-+            `sample_weight` is not `None` and its shape doesn't match `y_pred`, or if
-+            `variables_to_update` contains invalid keys.
-+    """
-+    if variables_to_update is None:
-+        return
-+    y_true = K.cast(y_true, dtype=K.floatx())
-+    y_pred = K.cast(y_pred, dtype=K.floatx())
-+    if sample_weight is not None:
-+        sample_weight = K.cast(sample_weight, dtype=K.floatx())
-+
-+    if not any(key
-+               for key in variables_to_update
-+               if key in list(ConfusionMatrix)):
-+        raise ValueError(
-+            'Please provide at least one valid confusion matrix '
-+            'variable to update. Valid variable key options are: "{}". '
-+            'Received: "{}"'.format(
-+                list(ConfusionMatrix), variables_to_update.keys()))
-+
-+    invalid_keys = [
-+        key for key in variables_to_update if key not in list(ConfusionMatrix)
-+    ]
-+    if invalid_keys:
-+        raise ValueError(
-+            'Invalid keys: {}. Valid variable key options are: "{}"'.format(
-+                invalid_keys, list(ConfusionMatrix)))
-+
-+    if sample_weight is None:
-+        y_pred, y_true = losses_utils.squeeze_or_expand_dimensions(
-+            y_pred, y_true=y_true)
-+    else:
-+        y_pred, y_true, sample_weight = (
-+            losses_utils.squeeze_or_expand_dimensions(
-+                y_pred, y_true=y_true, sample_weight=sample_weight))
-+
-+    if top_k is not None:
-+        y_pred = _filter_top_k(y_pred, top_k)
-+    if class_id is not None:
-+        y_true = y_true[..., class_id]
-+        y_pred = y_pred[..., class_id]
-+
-+    thresholds = to_list(thresholds)
-+    num_thresholds = len(thresholds)
-+    num_predictions = K.size(y_pred)
-+
-+    # Reshape predictions and labels.
-+    predictions_2d = K.reshape(y_pred, [1, -1])
-+    labels_2d = K.reshape(
-+        K.cast(y_true, dtype='bool'), [1, -1])
-+
-+    # Tile the thresholds for every prediction.
-+    thresh_tiled = K.tile(
-+        K.expand_dims(K.constant(thresholds), 1),
-+        K.stack([1, num_predictions]))
-+
-+    # Tile the predictions for every threshold.
-+    preds_tiled = K.tile(predictions_2d, [num_thresholds, 1])
-+
-+    # Compare predictions and threshold.
-+    pred_is_pos = K.greater(preds_tiled, thresh_tiled)
-+    pred_is_neg = K.greater(thresh_tiled, preds_tiled)
-+
-+    # Tile labels by number of thresholds
-+    label_is_pos = K.tile(labels_2d, [num_thresholds, 1])
-+
-+    if sample_weight is not None:
-+        weights = losses_utils.broadcast_weights(
-+            y_pred, K.cast(sample_weight, dtype=K.floatx()))
-+        weights_tiled = K.tile(
-+            K.reshape(weights, [1, -1]), [num_thresholds, 1])
-+    else:
-+        weights_tiled = None
-+
-+    update_ops = []
-+    loop_vars = {
-+        ConfusionMatrix.TRUE_POSITIVES: (label_is_pos, pred_is_pos),
-+    }
-+    update_tn = ConfusionMatrix.TRUE_NEGATIVES in variables_to_update
-+    update_fp = ConfusionMatrix.FALSE_POSITIVES in variables_to_update
-+    update_fn = ConfusionMatrix.FALSE_NEGATIVES in variables_to_update
-+
-+    if update_fn or update_tn:
-+        loop_vars[ConfusionMatrix.FALSE_NEGATIVES] = (label_is_pos, pred_is_neg)
-+
-+    if update_fp or update_tn:
-+        label_is_neg = K.equal(
-+            label_is_pos, K.zeros_like(label_is_pos, dtype=label_is_pos.dtype))
-+        loop_vars[ConfusionMatrix.FALSE_POSITIVES] = (label_is_neg, pred_is_pos)
-+    if update_tn:
-+        loop_vars[ConfusionMatrix.TRUE_NEGATIVES] = (label_is_neg, pred_is_neg)
-+
-+    for matrix_cond, (label, pred) in loop_vars.items():
-+        if matrix_cond in variables_to_update:
-+            update_ops.append(
-+                weighted_assign_add(label, pred, weights_tiled,
-+                                    variables_to_update[matrix_cond]))
-+    return update_ops
-+
--- 
-2.26.2
-