Trying to implement Tversky metric as follows:

```
import torch
def tversky_score(
predictions,
targets,
alpha=0.5,
beta=0.5,
eps=1e-16,
encode_target=True
):
"""
Ref A: https://arxiv.org/abs/1706.05721
alpha = beta = 0.5 : Dice coefficient
alpha = beta = 1 : Tanimoto coefficient / Jaccard Index
alpha + beta = 1 : Produces set of F*-scores
:param predictions:
:param targets:
:param alpha:
:param beta:
:param eps:
:param encode_target:
:return:
"""
if encode_target:
# noinspection PyArgumentList
gt = predictions.clone().zero_()
# noinspection PyArgumentList
assert (targets.ndim == 4) and (
targets.size(1) == 1
), "Only single channel images can be encoded!"
gt = gt.scatter_(1, targets.to(dtype=torch.int64), 1)
# gt.requires_grad = True
else:
gt = targets.clone()
# gt.requires_grad = True
# flatten label and prediction tensors
predictions = predictions.view(-1)
gt = gt.view(-1)
# True Positives, False Positives & False Negatives
tp = (predictions * gt).sum()
fp = ((1 - gt) * predictions).sum()
fn = (gt * (1 - predictions)).sum()
tversky = (tp + eps) / (
tp + alpha * fp + beta * fn + eps
)
return tversky
```

My loss functions are:

```
class FocalTverskyLoss(nn.Module):
def __init__(self, alpha=0.5, beta=0.5, gamma=1, smooth=1e-16):
"""
Ref A: https://arxiv.org/abs/1706.05721
alpha = beta = 0.5, gamma = 1 : Dice coefficient
alpha = beta = 1, gamma = 1 : Tanimoto coefficient / Jaccard Index
alpha + beta = 1, gamma = 1 : Produces set of F*-scores
:param alpha:
:param beta:
:param gamma:
:param smooth:
"""
super(FocalTverskyLoss, self).__init__()
self.alpha = alpha
self.beta = beta
self.gamma = gamma
self.eps = smooth
def forward(
self,
predictions: torch.Tensor,
targets: torch.Tensor,
encode_target: bool = True
):
tversky = tversky_score(
predictions=predictions,
targets=targets,
encode_target=encode_target,
alpha=self.alpha,
beta=self.beta,
eps=self.eps
)
focal_tversky = (1 - tversky) ** self.gamma
return focal_tversky
class PCHuberLoss(nn.Module):
def __init__(self, reduction='mean', delta=1.0):
super(PCHuberLoss, self).__init__()
self.net = nn.HuberLoss(
reduction=reduction, delta=delta
)
def forward(self, predictions, targets):
return self.net(predictions.F, targets.F)
class HybridLoss(nn.Module):
def __init__(
self,
alpha=0.5,
beta=0.5,
gamma=1,
smooth=1e-16,
reduction='mean',
delta=1.0,
p_factor=0.5,
i_factor=0.5,
encode_label=True
):
super(HybridLoss, self).__init__()
self.im_criterion = FocalTverskyLoss(
alpha=alpha,
beta=beta,
gamma=gamma,
smooth=smooth
)
self.pc_criterion = PCHuberLoss(
reduction=reduction,
delta=delta
)
self.p_f = p_factor
self.i_f = i_factor
self.img_encode = encode_label
def forward(self, predictions, targets):
loss = self.im_criterion(
predictions=predictions['label_tensor'],
targets=targets['label_tensor'],
encode_target=self.img_encode
)
if 'label' in predictions.keys():
loss = (self.i_f * loss) + (
self.p_f * self.pc_criterion(
predictions=predictions['point_tensor'],
targets=targets['point_tensor']
)
)
return loss
```

I use `HybridLoss`

to calculate loss. In `loss.backward()`

call I encounter `RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation`

. Possibly this is due to `zero_()`

call since it is an `in place`

operation. However, I am not sure how can I fix this. I would appreciate some pointers.