def classwise_accuracy(
output: torch.Tensor,
target: torch.Tensor,
num_classes: int = None,
topk: int = 1,
) -> Tuple[torch.Tensor, torch.Tensor]:
"""Computes the precision@k for each class respectively
Args:
output (:obj:`torch.Tensor`): The logits or probs as the classifier output
target (:obj:`torch.Tensor`): The ground truth labels
num_classes (`int`): The number of classes
topk (`int`): The k to computer precision@k for
Returns:
accuracy (:obj:`torch.Tensor`): The accuracy, i.e. the precision@k for
each class
counts (:obj:`torch.Tensor`): The number of data points of each class
"""
_, pred = output.topk(topk, dim=1, largest=True, sorted=True)
correct = pred.T.eq(target.view(-1)).sum(dim=0).bool()
counts = target.bincount(minlength=num_classes)
accuracy = target.bincount(weights=correct, minlength=num_classes) / counts
# classes = torch.arange(counts.size(0))
return accuracy, counts # , classes
def analyze_by_size(self, cluster_class: torch.Tensor, **kwargs) -> list[int]:
r"""The smallest cluster.
Args:
cluster_class (torch.Tensor): Clustering result tensor
with shape ``(N)``.
Returns:
list[int]: Predicted poison cluster classes list with shape ``(1)``
"""
return [cluster_class.bincount(minlength=self.nb_clusters).argmin().item()]
def forward( # type: ignore
self, inputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
inputs = torch.argmax(inputs, dim=1)
inputs = inputs.byte().flatten()
targets = targets.byte().flatten()
if self.ignore_index is not None:
is_not_ignore = targets != self.ignore_index
inputs = inputs[is_not_ignore]
targets = targets[is_not_ignore]
intersection = inputs[inputs == targets]
area_intersection = intersection.bincount(minlength=self.num_classes)
bincount_pred = inputs.bincount(minlength=self.num_classes)
bincount_true = targets.bincount(minlength=self.num_classes)
area_union = bincount_pred + bincount_true - area_intersection
mean_iou = torch.mean(area_intersection / (area_union + self.eps))
return mean_iou
def fit(self, X: torch.Tensor) -> None:
"""
Update the probs based on the observed counts using maximum likelihood
estimation; i.e., it computes the probabilities that maximize the data,
which reduces to the counts / total.
:param X: a 1-D tensor of emissions.
>>> CategoricalModel(3).fit(torch.tensor([0, 0, 1, 1, 2, 0]))
"""
counts = X.bincount(minlength=self.probs.shape[0]).float()
self.probs = (counts + self.prior) / (counts.sum() + self.prior.sum())
def intersection_and_union(preds: torch.Tensor, labels: torch.Tensor,
ignore_index=255, n_classes=19):
assert ignore_index > n_classes, 'ignore_index should be grater than n_classes'
preds = preds.byte().flatten()
labels = labels.byte().flatten()
is_not_ignore = labels != ignore_index
preds = preds[is_not_ignore]
labels = labels[is_not_ignore]
intersection = preds[preds == labels]
area_intersection = intersection.bincount(minlength=n_classes)
bincount_preds = preds.bincount(minlength=n_classes)
bincount_labels = labels.bincount(minlength=n_classes)
area_union = bincount_preds + bincount_labels - area_intersection
area_intersection = area_intersection.float().cpu().numpy()
area_union = area_union.float().cpu().numpy()
return area_intersection, area_union
def analyze_by_relative_size(self, cluster_class: torch.Tensor,
size_threshold: float = 0.35,
**kwargs) -> list[int]:
r"""Small clusters whose proportion is smaller than :attr:`size_threshold`.
Args:
cluster_class (torch.Tensor): Clustering result tensor
with shape ``(N)``.
size_threshold (float): Defaults to ``0.35``.
Returns:
list[int]: Predicted poison cluster classes list with shape ``(K)``
"""
relative_size = cluster_class.bincount(minlength=self.nb_clusters) / len(cluster_class)
return torch.arange(self.nb_clusters)[relative_size < size_threshold].tolist()
