BinaryCrossentropy
类keras.losses.BinaryCrossentropy(
from_logits=False,
label_smoothing=0.0,
axis=-1,
reduction="sum_over_batch_size",
name="binary_crossentropy",
dtype=None,
)
计算真实标签和预测标签之间的交叉熵损失。
将此交叉熵损失用于二分类(0 或 1)应用。损失函数需要以下输入:
y_true
(真实标签):值为 0 或 1。y_pred
(预测值):这是模型的预测,即一个浮点数值,表示一个 logit(当 from_logits=True
时,值在 [-inf, inf] 范围内),或者一个概率(当 from_logits=False
时,值在 [0., 1.] 范围内)。参数
y_pred
解释为 logit 值张量。默认情况下,我们假定 y_pred
是概率(即,值在 [0, 1] 范围内)。label_smoothing
的值越大,平滑程度越重。-1
。"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。示例
推荐用法:(设置 from_logits=True
)
通过 compile()
API
model.compile(
loss=keras.losses.BinaryCrossentropy(from_logits=True),
...
)
作为独立函数使用
>>> # Example 1: (batch_size = 1, number of samples = 4)
>>> y_true = np.array([0, 1, 0, 0])
>>> y_pred = np.array([-18.6, 0.51, 2.94, -12.8])
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True)
>>> bce(y_true, y_pred)
0.8654
>>> # Example 2: (batch_size = 2, number of samples = 4)
>>> y_true = np.array([[0, 1], [0, 0]])
>>> y_pred = np.array([[-18.6, 0.51], [2.94, -12.8]])
>>> # Using default 'auto'/'sum_over_batch_size' reduction type.
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True)
>>> bce(y_true, y_pred)
0.8654
>>> # Using 'sample_weight' attribute
>>> bce(y_true, y_pred, sample_weight=[0.8, 0.2])
0.243
>>> # Using 'sum' reduction` type.
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True,
... reduction="sum")
>>> bce(y_true, y_pred)
1.730
>>> # Using 'none' reduction type.
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True,
... reduction=None)
>>> bce(y_true, y_pred)
array([0.235, 1.496], dtype=float32)
默认用法:(设置 from_logits=False
)
>>> # Make the following updates to the above "Recommended Usage" section
>>> # 1. Set `from_logits=False`
>>> keras.losses.BinaryCrossentropy() # OR ...('from_logits=False')
>>> # 2. Update `y_pred` to use probabilities instead of logits
>>> y_pred = [0.6, 0.3, 0.2, 0.8] # OR [[0.6, 0.3], [0.2, 0.8]]
BinaryFocalCrossentropy
类keras.losses.BinaryFocalCrossentropy(
apply_class_balancing=False,
alpha=0.25,
gamma=2.0,
from_logits=False,
label_smoothing=0.0,
axis=-1,
reduction="sum_over_batch_size",
name="binary_focal_crossentropy",
dtype=None,
)
计算真实标签和预测之间的焦点交叉熵损失。
二元交叉熵损失常用于二分类(0 或 1)任务。损失函数需要以下输入:
y_true
(真实标签):值为 0 或 1。y_pred
(预测值):这是模型的预测,即一个浮点数值,表示一个 logit(当 from_logits=True
时,值在 [-inf, inf] 范围内),或者一个概率(当 from_logits=False
时,值在 [0., 1.]
范围内)。根据 Lin 等人,2018 年 的研究,应用“焦点因子”来降低易分类样本的权重并更多地关注难分类样本是有帮助的。默认情况下,焦点张量计算如下:
对于类别 1,focal_factor = (1 - output) ** gamma
;对于类别 0,focal_factor = output ** gamma
,其中 gamma
是一个聚焦参数。当 gamma=0
时,此函数等同于二元交叉熵损失。
参数
0.25
,如参考文献 Lin 等人,2018 年 中所述。类别 0 的权重为 1.0 - alpha
。2.0
,如参考文献 Lin 等人,2018 年 中所述。y_pred
解释为 logit 值张量。默认情况下,我们假定 y_pred
是概率(即,值在 [0, 1]
范围内)。[0, 1]
之间的浮点数。当为 0
时,不应用平滑。当 > 0
时,我们计算预测标签和真实标签的平滑版本之间的损失,其中平滑将标签向 0.5
靠拢。label_smoothing
的值越大,平滑程度越重。-1
。"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。示例
通过 compile()
API
model.compile(
loss=keras.losses.BinaryFocalCrossentropy(
gamma=2.0, from_logits=True),
...
)
作为独立函数使用
>>> # Example 1: (batch_size = 1, number of samples = 4)
>>> y_true = np.array([0, 1, 0, 0])
>>> y_pred = np.array([-18.6, 0.51, 2.94, -12.8])
>>> loss = keras.losses.BinaryFocalCrossentropy(
... gamma=2, from_logits=True)
>>> loss(y_true, y_pred)
0.691
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
... apply_class_balancing=True, gamma=2, from_logits=True)
>>> loss(y_true, y_pred)
0.51
>>> # Example 2: (batch_size = 2, number of samples = 4)
>>> y_true = np.array([[0, 1], [0, 0]])
>>> y_pred = np.array([[-18.6, 0.51], [2.94, -12.8]])
>>> # Using default 'auto'/'sum_over_batch_size' reduction type.
>>> loss = keras.losses.BinaryFocalCrossentropy(
... gamma=3, from_logits=True)
>>> loss(y_true, y_pred)
0.647
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
... apply_class_balancing=True, gamma=3, from_logits=True)
>>> loss(y_true, y_pred)
0.482
>>> # Using 'sample_weight' attribute with focal effect
>>> loss = keras.losses.BinaryFocalCrossentropy(
... gamma=3, from_logits=True)
>>> loss(y_true, y_pred, sample_weight=[0.8, 0.2])
0.133
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
... apply_class_balancing=True, gamma=3, from_logits=True)
>>> loss(y_true, y_pred, sample_weight=[0.8, 0.2])
0.097
>>> # Using 'sum' reduction` type.
>>> loss = keras.losses.BinaryFocalCrossentropy(
... gamma=4, from_logits=True,
... reduction="sum")
>>> loss(y_true, y_pred)
1.222
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
... apply_class_balancing=True, gamma=4, from_logits=True,
... reduction="sum")
>>> loss(y_true, y_pred)
0.914
>>> # Using 'none' reduction type.
>>> loss = keras.losses.BinaryFocalCrossentropy(
... gamma=5, from_logits=True,
... reduction=None)
>>> loss(y_true, y_pred)
array([0.0017 1.1561], dtype=float32)
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
... apply_class_balancing=True, gamma=5, from_logits=True,
... reduction=None)
>>> loss(y_true, y_pred)
array([0.0004 0.8670], dtype=float32)
CategoricalCrossentropy
类keras.losses.CategoricalCrossentropy(
from_logits=False,
label_smoothing=0.0,
axis=-1,
reduction="sum_over_batch_size",
name="categorical_crossentropy",
dtype=None,
)
计算标签和预测之间的交叉熵损失。
当有两个或更多标签类别时,使用此交叉熵损失函数。我们期望标签以 one_hot
格式提供。如果您想提供整数形式的标签,请使用 SparseCategoricalCrossentropy
损失。每个特征应该有 num_classes
个浮点数值,即 y_pred
和 y_true
的形状均为 [batch_size, num_classes]
。
参数
y_pred
是 logits 张量。默认情况下,我们假定 y_pred
编码一个概率分布。0.1
,非目标标签使用 0.1 / num_classes
,目标标签使用 0.9 + 0.1 / num_classes
。-1
。"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。示例
独立使用
>>> y_true = np.array([[0, 1, 0], [0, 0, 1]])
>>> y_pred = np.array([[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> cce = keras.losses.CategoricalCrossentropy()
>>> cce(y_true, y_pred)
1.177
>>> # Calling with 'sample_weight'.
>>> cce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
0.814
>>> # Using 'sum' reduction type.
>>> cce = keras.losses.CategoricalCrossentropy(
... reduction="sum")
>>> cce(y_true, y_pred)
2.354
>>> # Using 'none' reduction type.
>>> cce = keras.losses.CategoricalCrossentropy(
... reduction=None)
>>> cce(y_true, y_pred)
array([0.0513, 2.303], dtype=float32)
通过 compile()
API 使用
model.compile(optimizer='sgd',
loss=keras.losses.CategoricalCrossentropy())
CategoricalFocalCrossentropy
类keras.losses.CategoricalFocalCrossentropy(
alpha=0.25,
gamma=2.0,
from_logits=False,
label_smoothing=0.0,
axis=-1,
reduction="sum_over_batch_size",
name="categorical_focal_crossentropy",
dtype=None,
)
计算 alpha 平衡的焦点交叉熵损失。
当有两个或更多标签类别,并且您想在不使用 class_weights
的情况下处理类别不平衡时,使用此交叉熵损失函数。我们期望标签以 one_hot
格式提供。
根据 Lin 等人,2018 年 的研究,应用焦点因子来降低易分类样本的权重并更多地关注难分类样本是有帮助的。焦点损失 (FL) 的通用公式如下:
FL(p_t) = (1 - p_t) ** gamma * log(p_t)
其中 p_t
定义如下:p_t = output if y_true == 1, else 1 - output
(1 - p_t) ** gamma
是 modulating_factor
(调制因子),其中 gamma
是一个聚焦参数。当 gamma
= 0 时,对交叉熵没有焦点效应。gamma
以平滑的方式降低了简单样本的重要性。
作者在论文中使用了 alpha 平衡的焦点损失 (FL) 变体:FL(p_t) = -alpha * (1 - p_t) ** gamma * log(p_t)
其中 alpha
是类别的权重因子。如果 alpha
= 1,由于所有类别具有相同的权重,损失将无法正确处理类别不平衡。这可以是一个常数或一个常数列表。如果 alpha 是一个列表,其长度必须与类别数相同。
上述公式可以推广为:FL(p_t) = alpha * (1 - p_t) ** gamma * CrossEntropy(y_true, y_pred)
其中负号来自 CrossEntropy(y_true, y_pred)
(CE)。
将此推广到多类别情况很简单:FL(p_t) = alpha * (1 - p_t) ** gamma * CategoricalCE(y_true, y_pred)
在下面的代码片段中,每个样本有 num_classes
个浮点数值。y_pred
和 y_true
的形状均为 (batch_size, num_classes)
。
参数
0.25
,如参考文献中所述。它可以是浮点数列表或标量。在多类别情况下,可以通过使用 sklearn.utils
中的 compute_class_weight
根据类别的逆频率设置 alpha。2.0
,如参考文献中所述。它有助于以平滑的方式逐渐降低简单(易分类)样本的重要性。output
是 logits 张量。默认情况下,我们认为 output
编码一个概率分布。0.1
,非目标标签使用 0.1 / num_classes
,目标标签使用 0.9 + 0.1 / num_classes
。-1
。"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。示例
独立使用
>>> y_true = [[0., 1., 0.], [0., 0., 1.]]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> cce = keras.losses.CategoricalFocalCrossentropy()
>>> cce(y_true, y_pred)
0.23315276
>>> # Calling with 'sample_weight'.
>>> cce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
0.1632
>>> # Using 'sum' reduction type.
>>> cce = keras.losses.CategoricalFocalCrossentropy(
... reduction="sum")
>>> cce(y_true, y_pred)
0.46631
>>> # Using 'none' reduction type.
>>> cce = keras.losses.CategoricalFocalCrossentropy(
... reduction=None)
>>> cce(y_true, y_pred)
array([3.2058331e-05, 4.6627346e-01], dtype=float32)
通过 compile()
API 使用
model.compile(optimizer='adam',
loss=keras.losses.CategoricalFocalCrossentropy())
SparseCategoricalCrossentropy
类keras.losses.SparseCategoricalCrossentropy(
from_logits=False,
ignore_class=None,
reduction="sum_over_batch_size",
axis=-1,
name="sparse_categorical_crossentropy",
dtype=None,
)
计算标签和预测之间的交叉熵损失。
当有两个或更多标签类别时,使用此交叉熵损失函数。我们期望标签以整数形式提供。如果您想使用 one-hot
格式提供标签,请使用 CategoricalCrossentropy
损失。对于 y_pred
,每个特征应该有 # classes
个浮点数值;对于 y_true
,每个特征应该有一个浮点数值。
在下面的代码片段中,对于 y_true
,每个样本有一个浮点数值;对于 y_pred
,每个样本有 num_classes
个浮点数值。y_true
的形状是 [batch_size]
,y_pred
的形状是 [batch_size, num_classes]
。
参数
y_pred
是 logits 张量。默认情况下,我们假定 y_pred
编码一个概率分布。"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。-1
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。示例
>>> y_true = [1, 2]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> scce = keras.losses.SparseCategoricalCrossentropy()
>>> scce(y_true, y_pred)
1.177
>>> # Calling with 'sample_weight'.
>>> scce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
0.814
>>> # Using 'sum' reduction type.
>>> scce = keras.losses.SparseCategoricalCrossentropy(
... reduction="sum")
>>> scce(y_true, y_pred)
2.354
>>> # Using 'none' reduction type.
>>> scce = keras.losses.SparseCategoricalCrossentropy(
... reduction=None)
>>> scce(y_true, y_pred)
array([0.0513, 2.303], dtype=float32)
通过 compile()
API 使用
model.compile(optimizer='sgd',
loss=keras.losses.SparseCategoricalCrossentropy())
Poisson
类keras.losses.Poisson(reduction="sum_over_batch_size", name="poisson", dtype=None)
计算 y_true
与 y_pred
之间的泊松损失。
公式
loss = y_pred - y_true * log(y_pred)
参数
"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。CTC
类keras.losses.CTC(reduction="sum_over_batch_size", name="ctc", dtype=None)
CTC (Connectionist Temporal Classification) 损失。
参数
"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。KLDivergence
类keras.losses.KLDivergence(
reduction="sum_over_batch_size", name="kl_divergence", dtype=None
)
计算 y_true
与 y_pred
之间的 Kullback-Leibler 散度损失。
公式
loss = y_true * log(y_true / y_pred)
y_true
和 y_pred
预期是概率分布,值介于 0 和 1 之间。它们将被裁剪到 [0, 1]
范围。
参数
"sum_over_batch_size"
。支持的选项包括 "sum"
、"sum_over_batch_size"
、"mean"
、"mean_with_sample_weight"
或 None
。"sum"
对损失求和,"sum_over_batch_size"
和 "mean"
对损失求和并除以样本大小,"mean_with_sample_weight"
对损失求和并除以样本权重的总和。"none"
和 None
不执行聚合。默认为 "sum_over_batch_size"
。None
,表示使用 keras.backend.floatx()
。除非设置为其他值(通过 keras.backend.set_floatx()
),否则 keras.backend.floatx()
为 "float32"
。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。binary_crossentropy
函数keras.losses.binary_crossentropy(
y_true, y_pred, from_logits=False, label_smoothing=0.0, axis=-1
)
计算二元交叉熵损失。
参数
[batch_size, d0, .. dN]
。[batch_size, d0, .. dN]
。y_pred
是 logits 张量。默认情况下,我们假定 y_pred
编码一个概率分布。[0, 1]
之间的浮点数。如果 > 0
,则通过将标签向 0.5 挤压来平滑标签,即目标类别使用 1. - 0.5 * label_smoothing
,非目标类别使用 0.5 * label_smoothing
。-1
。返回值
二元交叉熵损失值。形状 = [batch_size, d0, .. dN-1]
。
示例
>>> y_true = [[0, 1], [0, 0]]
>>> y_pred = [[0.6, 0.4], [0.4, 0.6]]
>>> loss = keras.losses.binary_crossentropy(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.916 , 0.714], dtype=float32)
categorical_crossentropy
函数keras.losses.categorical_crossentropy(
y_true, y_pred, from_logits=False, label_smoothing=0.0, axis=-1
)
计算分类交叉熵损失。
参数
y_pred
是 logits 张量。默认情况下,我们假定 y_pred
编码一个概率分布。0
,则平滑标签。例如,如果为 0.1
,非目标标签使用 0.1 / num_classes
,目标标签使用 0.9 + 0.1 / num_classes
。-1
。计算熵时沿用的维度。返回值
分类交叉熵损失值。
示例
>>> y_true = [[0, 1, 0], [0, 0, 1]]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> loss = keras.losses.categorical_crossentropy(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.0513, 2.303], dtype=float32)
sparse_categorical_crossentropy
函数keras.losses.sparse_categorical_crossentropy(
y_true, y_pred, from_logits=False, ignore_class=None, axis=-1
)
计算稀疏分类交叉熵损失。
参数
y_pred
是 logits 张量。默认情况下,我们假定 y_pred
编码一个概率分布。ignore_class=None
),考虑所有类别。-1
。计算熵时沿用的维度。返回值
稀疏分类交叉熵损失值。
示例
>>> y_true = [1, 2]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> loss = keras.losses.sparse_categorical_crossentropy(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.0513, 2.303], dtype=float32)
poisson
函数keras.losses.poisson(y_true, y_pred)
计算 y_true 和 y_pred 之间的泊松损失。
公式
loss = y_pred - y_true * log(y_pred)
参数
[batch_size, d0, .. dN]
。[batch_size, d0, .. dN]
。返回值
泊松损失值,形状 = [batch_size, d0, .. dN-1]
。
示例
>>> y_true = np.random.randint(0, 2, size=(2, 3))
>>> y_pred = np.random.random(size=(2, 3))
>>> loss = keras.losses.poisson(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> y_pred = y_pred + 1e-7
>>> assert np.allclose(
... loss, np.mean(y_pred - y_true * np.log(y_pred), axis=-1),
... atol=1e-5)
ctc
函数keras.losses.ctc(y_true, y_pred)
CTC (Connectionist Temporal Classification) 损失。
参数
(batch_size, max_length)
的张量,包含整数格式的真实标签。0
始终表示空白/掩码索引,不应用于类别。(batch_size, max_length, num_classes)
的张量,包含 logits(模型的输出)。它们不应通过 softmax 进行归一化。kl_divergence
函数keras.losses.kl_divergence(y_true, y_pred)
计算 y_true
与 y_pred
之间的 Kullback-Leibler 散度损失。
公式
loss = y_true * log(y_true / y_pred)
y_true
和 y_pred
预期是概率分布,值介于 0 和 1 之间。它们将被裁剪到 [0, 1]
范围。
参数
返回值
KL 散度损失值,形状 = [batch_size, d0, .. dN-1]
。
示例
>>> y_true = np.random.randint(0, 2, size=(2, 3)).astype(np.float32)
>>> y_pred = np.random.random(size=(2, 3))
>>> loss = keras.losses.kl_divergence(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> y_true = ops.clip(y_true, 1e-7, 1)
>>> y_pred = ops.clip(y_pred, 1e-7, 1)
>>> assert np.array_equal(
... loss, np.sum(y_true * np.log(y_true / y_pred), axis=-1))