segmentation

Compute per-class intersection and union counts.

Parameters:

• preds (Tensor) –

  Predicted class indices, shape \((N,)\).

• target (Tensor) –

  Ground truth class indices, shape \((N,)\).

• num_classes (int) –

  Total number of classes.

• batch (Optional[Tensor], default: None ) –

  Optional per-point batch index for per-sample counts. One row is emitted per sample (even for samples whose points are all ignored, which count as zero).

• ignore_index (Optional[int], default: None ) –

  Class index to exclude. Points where target == ignore_index are dropped, and the returned intersection/union at this index are \(0\).

Returns:

• Tensor –

  Tuple \((\text{intersection}, \text{union})\), each of shape \((\text{num\_classes},)\)

• Tensor –

  or \((\text{batch\_size}, \text{num\_classes})\) if batch is provided.

Intersection over Union (IoU, the Jaccard index) of a confusion matrix.

Confusion matrices add up, so the matrix may describe one batch or the sum of confusion_matrix over a whole split. With average="macro" a class absent from the whole matrix (zero union) counts as zero_division, matching sklearn's jaccard_score(zero_division=0); toolboxes that average only over present classes report a higher value on splits missing a class, so compare published numbers accordingly.

Parameters:

• cm (Tensor) –

  Confusion matrix with true classes as rows, shape \((C, C)\) (see confusion_matrix).

• average (Literal['macro', 'none'], default: 'macro' ) –

  "macro" returns the mean IoU (mIoU) over the classes; "none" returns the per-class IoU.

• ignore_index (Union[int, Sequence[int], None], default: None ) –

  Class index, or indices, to ignore: points whose true class is ignored are dropped, and the ignored classes are left out of the mean. Indices outside \([0, C)\) have no effect.

• zero_division (float, default: 0.0 ) –

  IoU given to a class with zero union (and to the ignored classes with average="none").

• class_names (Optional[Sequence[str]], default: None ) –

  Name of each class index; with average="none" the per-class IoU comes back as a {name: iou} dict instead of a tensor.

Returns:

• Union[float, Tensor, Dict[str, float]] –

  The mean IoU as a float with average="macro", or the per-class IoU, shape \((C,)\), with average="none"

• Union[float, Tensor, Dict[str, float]] –

  (a {name: iou} dict when class_names is given).

>>> cm = torch.tensor([[1, 1], [0, 1]])
>>> intersection_over_union(cm)
0.5
>>> intersection_over_union(cm, average="none")
tensor([0.5000, 0.5000])
>>> intersection_over_union(cm, average="none", class_names=["wall", "floor"])
{'wall': 0.5, 'floor': 0.5}

Per-shape IoU averaged over the parts of the shape's category (the ShapeNetPart protocol).

Each shape is scored only over the part labels its category owns (e.g. ShapeNetPart's Airplane owns parts \([0, 1, 2, 3]\)); a part absent from both the prediction and the target counts as IoU \(1\).

Parameters:

• preds (Tensor) –

  Predicted part indices, shape \((N,)\).

• target (Tensor) –

  Ground truth part indices, shape \((N,)\).

• part_ids (Sequence[Sequence[int]]) –

  Part labels owned by each category, e.g. ShapeNetPart.seg_ids.values().

• category (Tensor) –

  Per-shape category index into part_ids, shape \((B,)\).

• batch (Optional[Tensor], default: None ) –

  Optional per-point shape index, shape \((N,)\); when omitted, all the points belong to one shape.

Returns:

• Tensor –

  Per-shape IoU tensor of shape \((B,)\).

>>> preds, target = torch.tensor([0, 1, 1, 1]), torch.tensor([0, 1, 0, 1])
>>> part_intersection_over_union(preds, target, part_ids=[[0, 1], [2, 3]], category=torch.tensor([0]))
tensor([0.5833])

Mean IoU of per-shape IoUs (the ShapeNetPart instance and class mIoU).

A shape's IoU does not depend on the other shapes of its batch, so the IoUs may come from one batch or be the part_intersection_over_union of every batch of a split, concatenated.

Parameters:

• ious (Tensor) –

  Per-shape IoUs (see part_intersection_over_union), shape \((B,)\).

• category (Tensor) –

  Per-shape category index, shape \((B,)\).

• average (Literal['micro', 'macro', 'none'], default: 'micro' ) –

  "micro" returns the instance mIoU (the mean over all shapes); "macro" returns the class mIoU (the mean, over the categories that have a shape, of their per-category means); "none" returns the per-category mean IoU.

• num_classes (Optional[int], default: None ) –

  Number of categories, i.e. the length of the average="none" output; defaults to the number of class_names, else to the largest category index met plus one.

• class_names (Optional[Sequence[str]], default: None ) –

  Name of each category index; with average="none" the per-category mean IoU comes back as a {name: iou} dict instead of a tensor.

Returns:

• Union[float, Tensor, Dict[str, float]] –

  The mIoU as a float with average="micro" or "macro" (NaN without any shape), or the per-category mean

• Union[float, Tensor, Dict[str, float]] –

  IoU, shape \((C,)\), with average="none" (a {name: iou} dict when class_names is given), holding NaN

• Union[float, Tensor, Dict[str, float]] –

  for the categories without any shape.

>>> ious, category = torch.tensor([1.0, 0.5, 0.0]), torch.tensor([0, 0, 1])
>>> part_mean_intersection_over_union(ious, category)
0.5
>>> part_mean_intersection_over_union(ious, category, average="macro")
0.375
>>> part_mean_intersection_over_union(ious, category, average="none", class_names=["Airplane", "Bag"])
{'Airplane': 0.75, 'Bag': 0.0}