[hybrid script] can not output consistent result when executing hybrid script by relay interpreter

Questions
#1

Hi all,
I register an operator named “nn.my_op”, its FTVMCompute attribute calls hybrid script compute_my_op function which is annotated by tvm.hybrid.script

@tvm.hybrid.script
def compute_my_op(x, y):
    # x, y both Tensor type
    res = …
    return res

RELAY_REGISTER_OP(“nn.my_op”)
.set_num_inputs(2)
.add_argument(“data1”, “Tensor”, “The input tensor.”)
.add_argument(“data2”, “Tensor”, “The input tensor.”)
.set_support_level(2)
.add_type_rel(" ", MyOpRel)
.set_attr(“FTVMCompute”, MyOpCompute);

when I create a nn.myop function node and execute it by relay interpreter, and when fed with the same input parameters, it output different matrix results which are sometimes correct, and sometimes wrong; moverover, some of the wrong results contain values of “nan” or “inf”

x = relay.var(‘x’, shape=(10, 10))
y = relay.var(‘y’, shape=(10, 10))
func = relay.Function([x, y], relay.nn.my_op(x, y))
intrp = create_executor(mod=mod, ctx=ctx, target=target)
for i in range(10):
    result = intrp.evaluate(expr)(*args)
    print(result, ‘\n’) ## output different result !!!

while i refer to test_hybrid_script.py and write test case with the following way, it works correctly

zz = compute_my_op(x, y)
s = tvm.create_schedule(C.op)
f = tvm.build(s, [x, y, zz], “llvm”)

a = tvm.ones((10, 10)).astype(‘float32’), ctx)
b = tvm.ones((10, 10)).astype(‘float32’), ctx)
c = tvm.nd.array(np.zeros((10, 10), dtype=a.dtype), ctx)
f(a, b, c) # The results c of each execution are the same

Does this mean relay interpreter can’t execute Op function whose computing calls hybrid script funciton?
or it is caused by something i did wrong, any idea how to solve this issue?

@were I found that the [hybrid script] module is developed by you, could you give me some tips? thank you！

#2

Can you also show me the whole code snippet of your hybrid script?

Can you also show me how you get the op of your written hybrid function?

I can support you asap.

#3

@were thanks for your kind reply.
my hybrid script func is as follows

@tvm.hybrid.script
def compute_my_op(x, y):
    #x.shape=(1, 1, 6, 6)
    #y.shape=(1, 1, 2, 2)
    batch = x.shape[0]
    channel = x.shape[1]
    height = y.shape[2]
    width = y.shape[3]
    kernel = (4, 4)
    strides = (2, 2)
    out = output_tensor(x.shape, y.dtype)

    for b in range(batch):
        for c in range(channel):
            for h in range(height):
                for w in range(width):
                    for i in range(h * strides[0], h * strides[0] + kernel[0])):
                        for j in range(w * strides[1], w * strides[1] + kernel[1])):
                            out[(b, c, i, j)] += y[(b, c, h, w)]

    return out

I also comment the statements of 6 for loop, then out is zero matrix, while out result is not when executed by relay interpreter

for you second question, i use tvm::runtime::Registry::Get() to get registered python function (named A) which is annotated with register_func(), and A calls hybrid script listed above.

thanks again for your help : )