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

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

"""Built-in loss functions.

"""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import abc

import six

from tensorflow.python.distribute import distribution_strategy_context

from tensorflow.python.framework import ops

from tensorflow.python.framework import smart_cond

from tensorflow.python.framework import tensor_util

from tensorflow.python.keras import backend as K

from tensorflow.python.keras.utils import losses_utils

from tensorflow.python.keras.utils import tf_utils

from tensorflow.python.keras.utils.generic_utils import deserialize_keras_object

from tensorflow.python.keras.utils.generic_utils import serialize_keras_object

from tensorflow.python.ops import array_ops

from tensorflow.python.ops import math_ops

from tensorflow.python.ops import nn

from tensorflow.python.ops.losses import losses_impl

from tensorflow.python.ops.losses import util as tf_losses_util

from tensorflow.python.util.tf_export import keras_export

from tensorflow.tools.docs import doc_controls

@keras_export('keras.losses.Loss')

class Loss(object):

return self.reduction

class LossFunctionWrapper(Loss):

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

@keras_export('keras.losses.MeanSquaredError')

class MeanSquaredError(LossFunctionWrapper):

mean_squared_error, name=name, reduction=reduction)

@keras_export('keras.losses.MeanAbsoluteError')

class MeanAbsoluteError(LossFunctionWrapper):

mean_absolute_error, name=name, reduction=reduction)

@keras_export('keras.losses.MeanAbsolutePercentageError')

class MeanAbsolutePercentageError(LossFunctionWrapper):

mean_absolute_percentage_error, name=name, reduction=reduction)

@keras_export('keras.losses.MeanSquaredLogarithmicError')

class MeanSquaredLogarithmicError(LossFunctionWrapper):

mean_squared_logarithmic_error, name=name, reduction=reduction)

@keras_export('keras.losses.BinaryCrossentropy')

class BinaryCrossentropy(LossFunctionWrapper):

self.from_logits = from_logits

@keras_export('keras.losses.CategoricalCrossentropy')

class CategoricalCrossentropy(LossFunctionWrapper):

label_smoothing=label_smoothing)

@keras_export('keras.losses.SparseCategoricalCrossentropy')

class SparseCategoricalCrossentropy(LossFunctionWrapper):

from_logits=from_logits)

@keras_export('keras.losses.Hinge')

class Hinge(LossFunctionWrapper):

super(Hinge, self).__init__(hinge, name=name, reduction=reduction)

@keras_export('keras.losses.SquaredHinge')

class SquaredHinge(LossFunctionWrapper):

squared_hinge, name=name, reduction=reduction)

@keras_export('keras.losses.CategoricalHinge')

class CategoricalHinge(LossFunctionWrapper):

categorical_hinge, name=name, reduction=reduction)

@keras_export('keras.losses.Poisson')

class Poisson(LossFunctionWrapper):

super(Poisson, self).__init__(poisson, name=name, reduction=reduction)

@keras_export('keras.losses.LogCosh')

class LogCosh(LossFunctionWrapper):

super(LogCosh, self).__init__(logcosh, name=name, reduction=reduction)

@keras_export('keras.losses.KLDivergence')

class KLDivergence(LossFunctionWrapper):

kullback_leibler_divergence, name=name, reduction=reduction)

@keras_export('keras.losses.Huber')

class Huber(LossFunctionWrapper):

huber_loss, name=name, reduction=reduction, delta=delta)

@keras_export('keras.metrics.mean_squared_error',

'keras.metrics.mse',

'keras.metrics.MSE',

'keras.losses.mean_squared_error',

'keras.losses.mse',

'keras.losses.MSE')

def mean_squared_error(y_true, y_pred):

y_pred = ops.convert_to_tensor(y_pred)

y_true = math_ops.cast(y_true, y_pred.dtype)

return K.mean(math_ops.squared_difference(y_pred, y_true), axis=-1)

@keras_export('keras.metrics.mean_absolute_error',

'keras.metrics.mae',

'keras.metrics.MAE',

'keras.losses.mean_absolute_error',

'keras.losses.mae',

'keras.losses.MAE')

def mean_absolute_error(y_true, y_pred):

y_pred = ops.convert_to_tensor(y_pred)

y_true = math_ops.cast(y_true, y_pred.dtype)

return K.mean(math_ops.abs(y_pred - y_true), axis=-1)

@keras_export('keras.metrics.mean_absolute_percentage_error',

'keras.metrics.mape',

'keras.metrics.MAPE',

'keras.losses.mean_absolute_percentage_error',

'keras.losses.mape',

'keras.losses.MAPE')

def mean_absolute_percentage_error(y_true, y_pred): # pylint: disable=missing-docstring

return 100. * K.mean(diff, axis=-1)

@keras_export('keras.metrics.mean_squared_logarithmic_error',

'keras.metrics.msle',

'keras.metrics.MSLE',

'keras.losses.mean_squared_logarithmic_error',

'keras.losses.msle',

'keras.losses.MSLE')

def mean_squared_logarithmic_error(y_true, y_pred): # pylint: disable=missing-docstring

return K.mean(math_ops.squared_difference(first_log, second_log), axis=-1)

def _maybe_convert_labels(y_true):

return updated_y_true

@keras_export('keras.metrics.squared_hinge', 'keras.losses.squared_hinge')

def squared_hinge(y_true, y_pred):

math_ops.square(math_ops.maximum(1. - y_true * y_pred, 0.)), axis=-1)

@keras_export('keras.metrics.hinge', 'keras.losses.hinge')

def hinge(y_true, y_pred):

return K.mean(math_ops.maximum(1. - y_true * y_pred, 0.), axis=-1)

@keras_export('keras.losses.categorical_hinge')

def categorical_hinge(y_true, y_pred):

return math_ops.maximum(0., neg - pos + 1.)

def huber_loss(y_true, y_pred, delta=1.0):

math_ops.multiply(delta, linear))

@keras_export('keras.losses.logcosh')

def logcosh(y_true, y_pred):

return K.mean(_logcosh(y_pred - y_true), axis=-1)

@keras_export('keras.metrics.categorical_crossentropy',

'keras.losses.categorical_crossentropy')

def categorical_crossentropy(y_true,

return K.categorical_crossentropy(y_true, y_pred, from_logits=from_logits)

@keras_export('keras.metrics.sparse_categorical_crossentropy',

'keras.losses.sparse_categorical_crossentropy')

def sparse_categorical_crossentropy(y_true, y_pred, from_logits=False, axis=-1):

return K.sparse_categorical_crossentropy(

y_true, y_pred, from_logits=from_logits, axis=axis)

@keras_export('keras.metrics.binary_crossentropy',

'keras.losses.binary_crossentropy')

def binary_crossentropy(y_true, y_pred, from_logits=False, label_smoothing=0): # pylint: disable=missing-docstring

K.binary_crossentropy(y_true, y_pred, from_logits=from_logits), axis=-1)

@keras_export('keras.metrics.kullback_leibler_divergence',

'keras.metrics.kld',

'keras.metrics.KLD',

'keras.losses.kullback_leibler_divergence',