Let suppose i have 60 classes and not all images have 60 classes.
So let say my first batch has 40 classes, so it will encoded it up to 40 classes and my second batch has 50 classes, so it encode it up to 50 classes. Shouldnot it be 60 class encoding in all batches?
Hi Talha!
Yes, you should encode all 60 classes for all of your batches even
if some batches don’t happen to have all 60 classes in them.
To expand on this a little: Your network architecture will have the
60 classes built into it (at least in standard approaches). Let’s say
that we label your 60 classes with the integers 0, …, 59. Now let’s
say that a particular batch happens to have only three classes in it,
specifically 3, 27, and 45. If you were to label this batch with, say, 0,
1, and 2, so that you gave class-27 the label 1, your network wouldn’t
know what that meant.
As an aside, whether you use one-hot encoding or something else
to label your classes is irrelevant to this question – you need all 60
either way. Having said that, you shouldn’t be using one-hot encoding.
Semantic segmentation is a classification problem (You classify
individual pixels.), so you would most typically use some version
of a cross-entropy-like loss function. Pytorch’s cross-entropy loss
functions use integer categorical class labels (like I alluded to, above),
and don’t work with one-hot encoding.
(You should also be aware that people sometimes – mistakenly – use
the term “one hot” to refer class labels of any sort, even if they are
not actually one-hot encoded. This, of course, can be confusing.)
Best.
K. Frank
I am using pytorch one hot function for this, in each batch I applied this function. do I need to some thing extra or this function internally manage that.
what other way is that find those images which have all 60 labels, use sklean one hot encoder and fit on it then on all rest of images, just transform it
Hi Talha!
Why are you using torch.nn.functional.one_hot()? I noted in my
previous that you probably don’t want to use one_hot(). What
is your specific goal?
Why do you want to find those images that have all 60 labels?
(It’s at least a possibility that no single image has all of the labels.)
What is your actual use case? What is your larger goal here?
Best.
K. Frank
I am trying to calculate dice coefficient for that purpose I need to average each class. for that I need one hot encoded vector. here is code
from einops import rearrange
def dice_coef_multilabel(mask_pred,mask_gt ):
def compute_dice_coefficient(mask_pred,mask_gt, smooth = 0.0001):
"""Compute soerensen-dice coefficient.
compute the soerensen-dice coefficient between the ground truth mask `mask_gt`
and the predicted mask `mask_pred`.
Args:
mask_gt: 4-dim Numpy array of type bool. The ground truth mask. [B, 1, H, W]
mask_pred: 4-dim Numpy array of type bool. The predicted mask. [B, C, H, W]
Returns:
the dice coeffcient as float. If both masks are empty, the result is NaN
"""
volume_sum = mask_gt.sum() + mask_pred.sum()
volume_intersect = (mask_gt * mask_pred).sum()
return (2*volume_intersect+smooth) / (volume_sum+smooth)
dice=0
n_pred_ch = mask_pred.shape[1]
mask_pred=torch.softmax(mask_pred, 1)
mask_gt=F.one_hot(mask_gt.long(), num_classes=n_pred_ch) #create one hot vector
mask_gt=rearrange(mask_gt, 'd0 d1 d2 d3 d4 -> d0 (d1 d4) d2 d3 ') #reshape one hot vector
for ind in range(1,n_pred_ch):
dice += compute_dice_coefficient(mask_gt[:,ind,:,:], mask_pred[:,ind,:,:])
return dice/n_pred_ch # taking average
Hi Talha!
Okay, for Dice loss, one_hot() makes sense.
This line from the code you’ve posted seems to indicate that you’ve
answered your own question.
To repeat my question from my previous post: Why do you want to
find those images that have all 60 labels?
As an aside, some people find that for semantic segmentation using
Dice loss to augment CrossEntropyLoss works better than using
Dice loss in isolation. You might want to explore that after you get
your Dice loss working.
Best.
K. Frank