[Bug][Relay] func ` _expr.const(c)` get an unexpected crash: 'NoneType' object has no attribute 'dtype'

[jikechao]

The PyTorch model with the adaptive_max_pool1d layer will lead to a crash.

Actual behavior

Traceback (most recent call last):
  File "test.py", line 22, in <module>
    mod, params = relay.frontend.from_pytorch(trace, input_shapes)
  File "/workplace/software/tvm/tvm/python/tvm/relay/frontend/pytorch.py", line 4970, in from_pytorch
    outputs = converter.convert_operators(operator_nodes, outputs, ret_name)
  File "/workplace/software/tvm/tvm/python/tvm/relay/frontend/pytorch.py", line 4256, in convert_operators
    return [_wrap_const(outputs[ret_name]) for ret_name in ret_names]
  File "/workplace/software/tvm/tvm/python/tvm/relay/frontend/pytorch.py", line 4256, in <listcomp>
    return [_wrap_const(outputs[ret_name]) for ret_name in ret_names]
  File "/workplace/software/tvm/tvm/python/tvm/relay/frontend/pytorch.py", line 4403, in _wrap_const
    return _expr.const(c)
  File "/workplace/software/tvm/tvm/python/tvm/relay/expr.py", line 677, in const
    value.dtype, None
AttributeError: 'NoneType' object has no attribute 'dtype'

Steps to reproduce

import torch
from tvm import relay
import tvm
import numpy as np
from torch.nn import Module

para_0 = torch.randn([1, 2, 2], dtype=torch.float32)

class adaptive_max_pool1d(Module):
        def forward(self, *args):
            return torch.nn.functional.adaptive_max_pool1d(args[0], 2, True)
m = adaptive_max_pool1d().float().eval()
print(m)

input_data=para_0

torch_outputs = m(input_data)
print(torch_outputs)
trace = torch.jit.trace(m, input_data)
input_shapes = [('input0', torch.Size([1, 2, 2]))]

mod, params = relay.frontend.from_pytorch(trace, input_shapes)

Triage

• frontend::pytorch

cc @echuraev @shingjan

[haoyang9804]

If I get it correctly, here is how the error occurs.
In the low-level library of PyTorch, pooling operator is separated into several sub-operators. For instance, adaptive_max_pool2d_0_0 pools the first dimension (the width dimension) while adaptive_max_pool2d_0_1 pools the second dimension (the height dimension) in a common 2-d tensor.
However, as for adaptive_max_pool1d, PyTorch also uses sub-operators, which areadaptive_max_pool1d_0_0 and adaptive_max_pool1d_0_1 to represent it. In this representation, adaptive_max_pool1d_0_0 actually takes charge of performing pooling while adaptive_max_pool1d_0_1 does nothing.
I don't know why the PyTorch developers design in this way, but to perfectly converting adaptive_max_pool1d in PyTorch, TVM developers maps this operator to the a tuple consisting of a call node in the high-level IR and a None. Here is the implementation in tvm/relay/frontend/pytorch.py.

def adaptive_max_pool(self, op, inputs, input_types):
        data = inputs[0]
        output_size = inputs[1]
        for i, item in enumerate(output_size):
            if isinstance(item, tvm.relay.expr.Constant):
                # convert Constant to int
                output_size[i] = item.data.numpy()[()]
        # returns dummy indices too
        return op(data, output_size=output_size), None

None will finally flow into the const function in tvm/relay/expr.py, which includes the following code:

if not dtype:
        # when dtype is None: int maps to "int32", float maps to "float32"
        dtype = {_np.dtype("int64"): _np.int32, _np.dtype("float64"): _np.float32}.get(
            value.dtype, None
        )

value here is None, and it certainly does not have dtype attribute.