Torchvision example on Mixup and CrossEntropyLoss

In PyTorch’s recent vision examples here: vision/ at main · pytorch/vision · GitHub
and vision/ at main · pytorch/vision · GitHub, it was shown how to use Mixup with the pipeline. I noticed when trying to use their Mixup function on my own that CrossEntropyLoss in general don’t expect targets to be of one-hot encoded, and it threw me a RuntimeError: Expected object of scalar type Long but got scalar type Float for argument #2 'target' in call to _thnn_nll_loss_forward error.

Am I missing something from the documentation

class RandomMixup(torch.nn.Module):
    """Randomly apply Mixup to the provided batch and targets.
    The class implements the data augmentations as described in the paper
    `"mixup: Beyond Empirical Risk Minimization" <>`_.
        num_classes (int): number of classes used for one-hot encoding.
        p (float): probability of the batch being transformed. Default value is 0.5.
        alpha (float): hyperparameter of the Beta distribution used for mixup.
            Default value is 1.0.
        inplace (bool): boolean to make this transform inplace. Default set to False.

    def __init__(self, num_classes: int, p: float = 0.5, alpha: float = 1.0, inplace: bool = False) -> None:
        assert num_classes > 0, "Please provide a valid positive value for the num_classes."
        assert alpha > 0, "Alpha param can't be zero."

        self.num_classes = num_classes
        self.p = p
        self.alpha = alpha
        self.inplace = inplace

    def forward(self, batch: Tensor, target: Tensor) -> Tuple[Tensor, Tensor]:
            batch (Tensor): Float tensor of size (B, C, H, W)
            target (Tensor): Integer tensor of size (B, )
            Tensor: Randomly transformed batch.
        if batch.ndim != 4:
            raise ValueError(f"Batch ndim should be 4. Got {batch.ndim}")
        if target.ndim != 1:
            raise ValueError(f"Target ndim should be 1. Got {target.ndim}")
        if not batch.is_floating_point():
            raise TypeError(f"Batch dtype should be a float tensor. Got {batch.dtype}.")
        if target.dtype != torch.int64:
            raise TypeError(f"Target dtype should be torch.int64. Got {target.dtype}")

        if not self.inplace:
            batch = batch.clone()
            target = target.clone()

        if target.ndim == 1:
            target = torch.nn.functional.one_hot(target, num_classes=self.num_classes).to(dtype=batch.dtype)

        if torch.rand(1).item() >= self.p:
            return batch, target

        # It's faster to roll the batch by one instead of shuffling it to create image pairs
        batch_rolled = batch.roll(1, 0)
        target_rolled = target.roll(1, 0)

        # Implemented as on mixup paper, page 3.
        lambda_param = float(torch._sample_dirichlet(torch.tensor([self.alpha, self.alpha]))[0])
        batch_rolled.mul_(1.0 - lambda_param)

        target_rolled.mul_(1.0 - lambda_param)

        return batch, target

where they did one hot encoded the targets.

Hi Hongnan!

Possibly relevant to your issue:

As of version 1.10, CrossEntropyLoss supports probabilistic targets (in
addition to integer-class-label targets). One-hot-encoded targets can be
understood as a special case of probabilistic targets. Earlier versions did
not support probabilistic targets (and hence not one-hot-encoded targets).

If you are seeing your issue with an earlier version, you might try upgrading
to the latest stable version, 1.10.1.


K. Frank

1 Like

I think that is the answer, I am still using 1.9.1.