def METHOD_NAME(data_shape, in_dtype, channels, axis):
    # Create placeholder variables for all qnn inputs.
    A = te.placeholder(data_shape, name="value", dtype="float32")
    D = te.placeholder([], name="dtype", dtype="int32")
    S = te.placeholder([te.size_var("scale_dim")], name="scale", dtype="float32")
    Z = te.placeholder([te.size_var("zp_dim")], name="zp", dtype="int32")
    SIM_DQ = topi.nn.simulated_dequantize(A, D, input_scale=S, input_zero_point=Z, axis=axis)
    # Create random numpy values to assign to inputs.
    a_np = np.random.uniform(low=-128, high=127, size=data_shape).astype(in_dtype)
    a_np_f = a_np.astype("float32")
    d_np = np.int32(topi.nn.SQNN_DTYPE_TO_CODE[in_dtype])
    s_np = np.random.uniform(low=1e-4, high=0.1, size=channels).astype("float32")
    z_np = np.random.uniform(low=-10, high=10, size=channels).astype("int32")
    dq_np = np.zeros(shape=data_shape, dtype="float32")
    def check_target(target, dev):
        # Wrap the numpy arrays in nd arrays.
        a = tvm.nd.array(a_np_f, dev)
        d = tvm.nd.array(d_np, dev)
        s = tvm.nd.array(s_np, dev)
        z = tvm.nd.array(z_np, dev)
        dq = tvm.nd.array(dq_np, dev)
        # Construct equivalent relay graph.
        per_channel = channels[0] != 1
        a_var = relay.var("a", shape=data_shape, dtype=in_dtype)
        if per_channel:
            s_var = relay.const(s_np)
            z_var = relay.const(z_np)
        else:
            s_var = relay.const(s_np[0])
            z_var = relay.const(z_np[0])
        real_dq_op = relay.qnn.op.dequantize(a_var, s_var, z_var, axis=axis)
        with tvm.transform.PassContext(opt_level=3):
            lib = relay.build(tvm.IRModule.from_expr(real_dq_op), target=target)
        # Get real qnn quantize output.
        m = graph_executor.GraphModule(lib["default"](dev))
        m.set_input("a", a_np)
        m.run()
        real_dq_out = m.get_output(0)
        # Compile the simulated quantize function.
        with tvm.target.Target(target):
            sched = tvm.topi.testing.get_injective_schedule(target)(SIM_DQ)
        func = tvm.build(sched, [A, D, S, Z, SIM_DQ], target, name="sim_quantize")
        func(a, d, s, z, dq)
        # Check correctness against the true qnn output.
        tvm.testing.assert_allclose(dq.numpy(), real_dq_out.numpy().astype("float32"), rtol=1e-5)
    for target, dev in tvm.testing.enabled_targets():
        check_target(target, dev)