Several `torch.*` functions raise uninformative `NotImplementedError`s when called with integer `dtype`

[rec]

🐛 Describe the bug

What happens

torch.rand((3,), dtype=torch.int32) raises the rather enigmatic NotImplementedError: "check_uniform_bounds" not implemented for 'Long'.

A different but similarly uninformative exception is raised for torch.randn: NotImplementedError: "normal_kernel_cpu" not implemented for 'Long'. Later work found other examples like & so the problem is fairly wide.

What should actually happen

Those code snippets should raise the same exception with a better message.

NotImplementedError: torch.rand only returns floating point Tensors. Did you mean torch.randint? and NotImplementedError: torch.randn only returns floating point Tensors

ValueError would technically be more accurate because, for example, torch.rand is implemented - it's just that the dtype parameter has the right type, but the wrong value (even though that value is a type 😁).

But other code downstream might rely on NotImplementedError, though this seems undocumented. Having a suboptimal exception type is not a grave sin compared with possible breakage. (If people are relying on that exact error text, well, they should expect breakage.)

Scope

I examined just the torch.* functions whose name contained the string rand, and I identified only rand, randn, rand_like and randn_like as having this problem. The torch.randint and torch.randint_like functions were well-behaved, with seemingly correct results for many dtypes.

Once I get to the root of it, I might identify other ops which might benefit from this change.

The hope is that there is one fairly logical spot where we can catch NotImplementedError e for all the ops, ascertain completely that the wrong dtype is the correct cause, and if so, overwrite e.args with our better message, then reraise. There will be a little extra work to find a possible "Did you mean?"

Most of the work is finding that one spot. I would expect this to be small but non-trivial.

cc @malfet

[vadimkantorov]

A bit related for supporting dtype=torch.bool for rand* functions - produces similar errors :( :

• torch.bernoulli and torch.rand to support dtype=torch.bool kwarg (and sypport operation of tensor.uniform_ on bool tensors) #35527 (comment)

Instead of only returning float tensors, maybe torch.rand can be upgraded to do randint if specifically instructed so with dtype arg and if bounds are integral

[rec]

In somewhat-related work in typing, I just saw this familiar, unhelpful message

>>> 1 & torch.tensor((1.0, 2.0))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NotImplementedError: "bitwise_and_cpu" not implemented for 'Float'

So I'm going to change the title of this issue. 😀

[rec]

@vadimkantorov

Instead of only returning float tensors, maybe torch.rand can be upgraded to do randint if specifically instructed so with dtype arg and if bounds are integral

I suggested this in an initial draft of this issue, but I realized that the signatures are not the same.

torch.randint(low=0, high, size, \*, ...) vs torch.rand(*size, *, ...)

It isn't a mistake: there's no obvious non-arbitrary default for high in randint except the useless 0 but rand has the obvious default of the unit interval.

[vadimkantorov]

default for low/high could be the min/max value of the provided dtype

At least, for dtype=torch.bool it makes practical sense (and maybe even clearer than randint((0, 2), dtype=torch.bool)). Could make practical sense also for small dtypes like u/int8, u/int16

[michellemadubuike]

Hi @rec @vadimkantorov , I worked on a fix recently for an issue and came across the NotImplemented Error. Turns out a lot of torch functions rely on the NotImplemented Error as I received the error when working with torch.binomial().
NotImplementedError: "binomial_cpu" not implemented for 'Long'

I found the NotImplemented error was located at pytorch/aten/src/ATEN/Dispatch.h Lines 193 - 211.

#define AT_DISPATCH_SWITCH(TYPE, NAME, ...)                                 \
  [&] {                                                                     \
    const auto& the_type = TYPE;                                            \
    constexpr const char* at_dispatch_name = NAME;                          \
    /* don't use TYPE again in case it is an expensive or side-effect op */ \
    at::ScalarType _st = ::detail::scalar_type(the_type);                   \
    RECORD_KERNEL_FUNCTION_DTYPE(at_dispatch_name, _st);                    \
    switch (_st) {                                                          \
      __VA_ARGS__                                                           \
      default:                                                              \
        TORCH_CHECK_NOT_IMPLEMENTED(                                        \
            false,                                                          \
            '"',                                                            \
            at_dispatch_name,                                               \
            "\" not implemented for '",                                     \
            toString(_st),                                                  \
            "'");                                                           \
    }                                                                       \
  }()