Pytorch：如何计算用于语义分割的 IoU（Jaccard 指数）

Question

有人可以提供一个玩具示例，说明如何在 pytorch 中计算用于语义分割的 IoU（联合交集）吗？

Answer 1

我在某处找到这个并为我改编了它。如果我能再次找到它，我会 post link。抱歉，如果这是重复的。
这里的关键函数是名为 iou 的函数。包装函数 evaluate_performance 并不通用，但它表明在计算 IoU 之前需要遍历所有结果。

import torch 
import pandas as pd  # For filelist reading
import myPytorchDatasetClass  # Custom dataset class, inherited from torch.utils.data.dataset


def iou(pred, target, n_classes = 12):
  ious = []
  pred = pred.view(-1)
  target = target.view(-1)

  # Ignore IoU for background class ("0")
  for cls in xrange(1, n_classes):  # This goes from 1:n_classes-1 -> class "0" is ignored
    pred_inds = pred == cls
    target_inds = target == cls
    intersection = (pred_inds[target_inds]).long().sum().data.cpu()[0]  # Cast to long to prevent overflows
    union = pred_inds.long().sum().data.cpu()[0] + target_inds.long().sum().data.cpu()[0] - intersection
    if union == 0:
      ious.append(float('nan'))  # If there is no ground truth, do not include in evaluation
    else:
      ious.append(float(intersection) / float(max(union, 1)))
  return np.array(ious)


def evaluate_performance(net):
    # Dataloader for test data
    batch_size = 1  
    filelist_name_test = '/path/to/my/test/filelist.txt'
    data_root_test = '/path/to/my/data/'
    dset_test = myPytorchDatasetClass.CustomDataset(filelist_name_test, data_root_test)
    test_loader = torch.utils.data.DataLoader(dataset=dset_test,  
                                              batch_size=batch_size,
                                              shuffle=False,
                                              pin_memory=True)
    data_info = pd.read_csv(filelist_name_test, header=None)
    num_test_files = data_info.shape[0]  
    sample_size = num_test_files

    # Containers for results
    preds = Variable(torch.zeros((sample_size, 60, 36, 60)))
    gts = Variable(torch.zeros((sample_size, 60, 36, 60)))

    dataiter = iter(test_loader) 
    for i in xrange(sample_size):
        images, labels, filename = dataiter.next()
        images = Variable(images).cuda()
        labels = Variable(labels)
        gts[i:i+batch_size, :, :, :] = labels
        outputs = net(images)
        outputs = outputs.permute(0, 2, 3, 4, 1).contiguous()
        val, pred = torch.max(outputs, 4)
        preds[i:i+batch_size, :, :, :] = pred.cpu()
    acc = iou(preds, gts)
    return acc

Answer 2

假设你的输出是形状 [32, 256, 256] # 32 是小批量大小，256x256 是图像的高度和宽度，标签也是相同的形状。

然后你可以在一些重塑之后使用sklearn的jaccard_similarity_score。

如果两者都是火炬张量，则：

lbl = labels.cpu().numpy().reshape(-1)
target = output.cpu().numpy().reshape(-1)

现在：

from sklearn.metrics import jaccard_similarity_score as jsc
print(jsc(target,lbl))

Answer 3

到 2021 年，无需实施您自己的 IoU，因为 torchmetrics 已配备 - here's the link。它被命名为 torchmetrics.JaccardIndex（以前是 torchmetrics.IoU）并计算你想要的。它适用于 PyTorch 和 PyTorch Lightning，也适用于分布式训练。

来自文档：

torchmetrics.JaccardIndex(num_classes, ignore_index=None, absent_score=0.0, threshold=0.5, multilabel=False, reduction='elementwise_mean', compute_on_step=None, **kwargs)

Computes Intersection over union, or Jaccard index calculation:

J(A,B) = \frac{|A\cap B|}{|A\cup B|}

Where: A and B are both tensors of the same size, containing integer class values. They may be subject to conversion from input data (see description below). Note that it is different from box IoU.

Works with binary, multiclass and multi-label data. Accepts probabilities from a model output or integer class values in prediction. Works with multi-dimensional preds and target.

Forward accepts

preds (float or long tensor): (N, ...) or (N, C, ...) where C is the number of classes

target (long tensor): (N, ...) If preds and target are the same shape and preds is a float tensor, we use the self.threshold argument to convert into integer labels. This is the case for binary and multi-label probabilities.

If preds has an extra dimension as in the case of multi-class scores we perform an argmax on dim=1.

官方示例：

>>> from torchmetrics import JaccardIndex
>>> target = torch.randint(0, 2, (10, 25, 25))
>>> pred = torch.tensor(target)
>>> pred[2:5, 7:13, 9:15] = 1 - pred[2:5, 7:13, 9:15]
>>> jaccard = JaccardIndex(num_classes=2)
>>> jaccard(pred, target)
tensor(0.9660)

Pytorch：如何计算用于语义分割的 IoU（Jaccard 指数）

Pytorch: How to compute IoU (Jaccard Index) for semantic segmentation

pytorch