機率損失

`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.] 範圍內)。

參數

from_logits：是否將 y_pred 解釋為 logit 值的張量。預設情況下，我們假設 y_pred 是機率 (即 [0, 1] 範圍內的值)。
label_smoothing：範圍在 [0, 1] 的浮點數。當為 0 時，不會發生平滑處理。當 > 0 時，我們會計算預測標籤和真實標籤的平滑版本之間的損失，其中平滑會將標籤擠向 0.5。較大的 label_smoothing 值對應於較重的平滑處理。
axis：計算交叉熵的軸 (特徵軸)。預設為 -1。
reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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 時，此函數等同於二元交叉熵損失。

參數

apply_class_balancing：一個布林值，表示是否對二元類別 0 和 1 套用權重平衡。
alpha：類別 1 的權重平衡因子，預設值為 0.25，如參考文獻 Lin 等人，2018 年中所述。類別 0 的權重為 1.0 - alpha。
gamma：用於計算焦點因子的聚焦參數，預設值為 2.0，如參考文獻 Lin 等人，2018 年中所述。
from_logits：是否將 y_pred 解釋為 logit 值的張量。預設情況下，我們假設 y_pred 是機率 (即 [0, 1] 範圍內的值)。
label_smoothing：範圍在 [0, 1] 的浮點數。當為 0 時，不會發生平滑處理。當 > 0 時，我們會計算預測標籤和真實標籤的平滑版本之間的損失，其中平滑會將標籤擠向 0.5。較大的 label_smoothing 值對應於較重的平滑處理。
axis：計算交叉熵的軸 (特徵軸)。預設為 -1。
reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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]。

參數

from_logits：是否期望 y_pred 為 logits 張量。預設情況下，我們假設 y_pred 編碼機率分佈。
label_smoothing：範圍在 [0, 1] 的浮點數。當 > 0 時，標籤值會平滑，這表示放寬對標籤值的信心。例如，如果為 0.1，則對於非目標標籤使用 0.1 / num_classes，對於目標標籤使用 0.9 + 0.1 / num_classes。
axis：計算交叉熵的軸 (特徵軸)。預設為 -1。
reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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 以平滑的方式減少簡單範例的重要性。

作者在論文中使用焦點損失 (FL) 的 alpha 平衡變體：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)。

參數

alpha：所有類別的權重平衡因子，預設值為 0.25，如參考文獻中所述。它可以是浮點數的清單或純量。在多類別情況下，可以使用 sklearn.utils 中的 compute_class_weight，依反向類別頻率設定 alpha。
gamma：聚焦參數，預設值為 2.0，如參考文獻中所述。它有助於以平滑的方式逐步減少簡單 (容易) 範例的重要性。
from_logits：是否期望 output 為 logits 張量。預設情況下，我們認為 output 編碼機率分佈。
label_smoothing：範圍在 [0, 1] 的浮點數。當 > 0 時，標籤值會平滑，這表示放寬對標籤值的信心。例如，如果為 0.1，則對於非目標標籤使用 0.1 / num_classes，對於目標標籤使用 0.9 + 0.1 / num_classes。
axis：計算交叉熵的軸 (特徵軸)。預設為 -1。
reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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",
    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]。

參數

from_logits：是否期望 y_pred 為 logits 張量。預設情況下，我們假設 y_pred 編碼機率分佈。
reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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 之間的 Poisson 損失。

公式

loss = y_pred - y_true * log(y_pred)

參數

reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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) 損失。

參數

reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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] 範圍內。

參數

reduction：要套用到損失的縮減類型。在幾乎所有情況下，這應該是 "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"。
name：損失執行個體的可選名稱。
dtype：損失計算的 dtype。預設為 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
)

計算二元交叉熵損失。

參數

y_true：真實值。形狀 = [batch_size, d0, .. dN]。
y_pred：預測值。形狀 = [batch_size, d0, .. dN]。
from_logits：是否期望 y_pred 為 logits 張量。預設情況下，我們假設 y_pred 編碼機率分佈。
label_smoothing：範圍在 [0, 1] 的浮點數。如果 > 0，則將標籤擠向 0.5 以平滑標籤，也就是說，針對目標類別使用 1. - 0.5 * label_smoothing，針對非目標類別使用 0.5 * label_smoothing。
axis：計算平均值的軸。預設為 -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_true: 單熱編碼的真實目標張量。
y_pred: 預測目標張量。
from_logits：是否期望 y_pred 為 logits 張量。預設情況下，我們假設 y_pred 編碼機率分佈。
label_smoothing: 介於 [0, 1] 之間的浮點數。如果 > 0，則平滑標籤。例如，如果為 0.1，則對於非目標標籤使用 0.1 / num_classes，對於目標標籤使用 0.9 + 0.1 / num_classes。
axis: 預設為 -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_true: 真實值。
y_pred: 預測值。
from_logits：是否期望 y_pred 為 logits 張量。預設情況下，我們假設 y_pred 編碼機率分佈。
ignore_class: 可選整數。在損失計算期間要忽略的類別 ID。這在分割問題中很有用，例如在分割圖中包含「void」類別（通常為 -1 或 255）。預設情況下 (ignore_class=None)，所有類別都會被考慮。
axis: 預設為 -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)

參數

y_true：真實值。形狀 = [batch_size, d0, .. dN]。
y_pred：預測值。形狀 = [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) 損失。

參數

y_true: 形狀為 (batch_size, max_length) 的張量，包含整數格式的真實標籤。0 始終代表空白/遮罩索引，不應用於類別。
y_pred: 形狀為 (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] 範圍內。

參數

y_true: 真實目標張量。
y_pred: 預測目標張量。

傳回

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))

機率損失

BinaryCrossentropy 類別

BinaryFocalCrossentropy 類別

CategoricalCrossentropy 類別

CategoricalFocalCrossentropy 類別

SparseCategoricalCrossentropy 類別

Poisson 類別

CTC 類別

KLDivergence 類別

binary_crossentropy 函數

categorical_crossentropy 函數

sparse_categorical_crossentropy 函數

poisson 函數

ctc 函數

kl_divergence 函數

機率損失

BinaryCrossentropy 類別

BinaryFocalCrossentropy 類別

CategoricalCrossentropy 類別

CategoricalFocalCrossentropy 類別

SparseCategoricalCrossentropy 類別

Poisson 類別

CTC 類別

KLDivergence 類別

binary_crossentropy 函數

categorical_crossentropy 函數

sparse_categorical_crossentropy 函數

poisson 函數

ctc 函數

kl_divergence 函數

`BinaryCrossentropy` 類別

`BinaryFocalCrossentropy` 類別

`CategoricalCrossentropy` 類別

`CategoricalFocalCrossentropy` 類別

`SparseCategoricalCrossentropy` 類別

`Poisson` 類別

`CTC` 類別

`KLDivergence` 類別

`binary_crossentropy` 函數

`categorical_crossentropy` 函數

`sparse_categorical_crossentropy` 函數

`poisson` 函數

`ctc` 函數

`kl_divergence` 函數