Implements the Weighted Kappa loss function.
tfa.losses.WeightedKappaLoss(
num_classes: int,
weightage: Optional[str] = 'quadratic',
name: Optional[str] = 'cohen_kappa_loss',
epsilon: Optional[Number] = 1e-06,
reduction: str = tf.keras.losses.Reduction.NONE
)
Weighted Kappa loss was introduced in the
Weighted kappa loss function for multi-class classification
of ordinal data in deep learning.
Weighted Kappa is widely used in Ordinal Classification Problems.
The loss value lies in \( [-\infty, \log 2] \), where \( \log 2 \)
means the random prediction.
Usage:
kappa_loss = tfa.losses.WeightedKappaLoss(num_classes=4)
y_true = tf.constant([[0, 0, 1, 0], [0, 1, 0, 0],
[1, 0, 0, 0], [0, 0, 0, 1]])
y_pred = tf.constant([[0.1, 0.2, 0.6, 0.1], [0.1, 0.5, 0.3, 0.1],
[0.8, 0.05, 0.05, 0.1], [0.01, 0.09, 0.1, 0.8]])
loss = kappa_loss(y_true, y_pred)
loss
<tf.Tensor: shape=(), dtype=float32, numpy=-1.1611925>
Usage with tf.keras
API:
model = tf.keras.Model()
model.compile('sgd', loss=tfa.losses.WeightedKappaLoss(num_classes=4))
<... outputs should be softmax results
if you want to weight the samples, just multiply the outputs
by the sample weight ...>
Args |
num_classes
|
Number of unique classes in your dataset.
|
weightage
|
(Optional) Weighting to be considered for calculating
kappa statistics. A valid value is one of
['linear', 'quadratic']. Defaults to 'quadratic'.
|
name
|
(Optional) String name of the metric instance.
|
epsilon
|
(Optional) increment to avoid log zero,
so the loss will be \( \log(1 - k + \epsilon) \), where \( k \) lies
in \( [-1, 1] \). Defaults to 1e-6.
|
Raises |
ValueError
|
If the value passed for weightage is invalid
i.e. not any one of ['linear', 'quadratic']
|
Methods
from_config
@classmethod
from_config(
config
)
Instantiates a Loss
from its config (output of get_config()
).
Args |
config
|
Output of get_config() .
|
get_config
View source
get_config()
Returns the config dictionary for a Loss
instance.
__call__
__call__(
y_true, y_pred, sample_weight=None
)
Invokes the Loss
instance.
Args |
y_true
|
Ground truth values. shape = [batch_size, d0, .. dN] , except
sparse loss functions such as sparse categorical crossentropy where
shape = [batch_size, d0, .. dN-1]
|
y_pred
|
The predicted values. shape = [batch_size, d0, .. dN]
|
sample_weight
|
Optional sample_weight acts as a coefficient for the
loss. If a scalar is provided, then the loss is simply scaled by the
given value. If sample_weight is a tensor of size [batch_size] , then
the total loss for each sample of the batch is rescaled by the
corresponding element in the sample_weight vector. If the shape of
sample_weight is [batch_size, d0, .. dN-1] (or can be broadcasted to
this shape), then each loss element of y_pred is scaled
by the corresponding value of sample_weight . (Note ondN-1 : all loss
functions reduce by 1 dimension, usually axis=-1.)
|
Returns |
Weighted loss float Tensor . If reduction is NONE , this has
shape [batch_size, d0, .. dN-1] ; otherwise, it is scalar. (Note dN-1
because all loss functions reduce by 1 dimension, usually axis=-1.)
|
Raises |
ValueError
|
If the shape of sample_weight is invalid.
|