比较2个Relay expr的结构图/数据流图是否一致

analysis.alpha_equal
analysis.graph_equal
定义文件：python/tvm/relay/analysis.py

  1. # file : python/tvm/relay/analysis.py
  3. def alpha_equal(lhs, rhs):
  4.     """
  5.     比较两个Relay expr的结构等效（alpha等效）。
  6.     """
  7.     return bool(_make._alpha_equal(lhs, rhs))
  10. def assert_alpha_equal(lhs, rhs):
  11.     _make._assert_alpha_equal(lhs, rhs)
  13. def graph_equal(lhs, rhs):
  14.     """
  15.      比较两个Relay expr的数据流等效。
  16.      这个和alpha_equal的区别在于它不要求变量lhs和rhs匹配，它们被视为源并相互映射。
  17.     """
  18.     return bool(_make._graph_equal(lhs, rhs))
  20. def assert_graph_equal(lhs, rhs):
  21.     _make._assert_graph_equal(lhs, rhs)

比较2个tensor值是否一致

tvm.testing.assert_allclose
定义文件:python/tvm/testing.py

  1. def assert_allclose(actual, desired, rtol=1e-7, atol=1e-7):
  2.     """ Version of np.testing.assert_allclose with `atol` and `rtol` fields set
  3.     in reasonable defaults.
  5.     Arguments `actual` and `desired` are not interchangable, since the function
  6.     compares the `abs(actual-desired)` with `atol+rtol*abs(desired)`.  Since we
  7.     often allow `desired` to be close to zero, we generally want non-zero `atol`.
  8.     """
  9.     np.testing.assert_allclose(actual, desired, rtol=rtol, atol=atol, verbose=True)

它和np.testing.assert_allclose等效，其中带有“ atol”和“ rtol”字段的设置为合理的默认值。
numpy中还有其它的比较函数，如下：

  1. # numpy.testing.assert_allclose(actual, desired, rtol=1e-07, atol=0, equal_nan=True, err_msg='', verbose=True)
  2. # Raises an AssertionError if two objects are not equal up to desired tolerance.
  3. # The test is equivalent to allclose(actual, desired, rtol, atol) (note that allclose has different default values). It compares the difference between actual and desired to atol + rtol * abs(desired).
  4. x = [1e-5, 1e-3, 1e-1]
  5. y = np.arccos(np.cos(x))
  6. np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)
  8. # numpy.testing.assert_array_almost_equal_nulp(x, y, nulp=1)
  9. # Compare two arrays relatively to their spacing.
  10. # This is a relatively robust method to compare two arrays whose amplitude is variable.
  11. x = np.array([1., 1e-10, 1e-20])
  12. eps = np.finfo(x.dtype).eps
  13. np.testing.assert_array_almost_equal_nulp(x, x*eps/2 + x)
  15. # numpy.testing.assert_array_max_ulp(a, b, maxulp=1, dtype=None)
  16. # Check that all items of arrays differ in at most N Units in the Last Place.
  17. a = np.linspace(0., 1., 100)
  18. res = np.testing.assert_array_max_ulp(a, np.arcsin(np.sin(a)))
  20. # numpy.testing.assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True)[source]
  21. # Raises an AssertionError if two objects are not equal up to desired precision.

assert_allclose的示例：

  1. def test_any_concat():
  2.     x = relay.var('x', shape=(relay.Any(), 2), dtype="float32")
  3.     y = relay.var('y', shape=(1, 2), dtype="float32")
  4.     z = relay.op.concatenate([x, y], axis=0)
  6.     mod = relay.module.Module()
  7.     mod["main"] = relay.Function([x, y], z)
  9.     x_np = np.random.uniform(size=(3, 2)).astype('float32')
  10.     y_np = np.random.uniform(size=(1, 2)).astype('float32')
  11.     ref = np.concatenate([x_np, y_np], axis=0)
  13.     for kind in ["debug", "vm"]:
  14.         ex = relay.create_executor(kind, mod=mod, ctx=tvm.cpu(), target="llvm")
  15.         result = ex.evaluate()(x_np, y_np)
  16.         tvm.testing.assert_allclose(result.asnumpy(), ref)
  1. import numpy as np
  2. import tvm
  3. from tvm import relay
  4. from tvm.contrib.nvcc import have_fp16
  6. def test_basic_build():
  7.     tgt = "llvm"
  8.     ctx = tvm.cpu()
  9.     # func
  10.     a = relay.var("a", dtype="float32", shape=(16, 8))
  11.     b = relay.var("b", dtype="float32", shape=(8, 8))
  12.     c = relay.var("c", dtype="float32", shape=(16, 8))
  13.     x = relay.nn.dense(a, b)
  14.     y = relay.nn.relu(x)
  15.     z = y + c
  16.     func = relay.Function([a, b, c], z)
  17.     A = tvm.nd.array(np.random.uniform(-1, 1, (16, 8)).astype("float32"), ctx=ctx)
  18.     B = tvm.nd.array(np.random.uniform(-1, 1, (8, 8)).astype("float32"), ctx=ctx)
  19.     C = tvm.nd.array(np.random.uniform(-1, 1, (16, 8)).astype("float32"), ctx=ctx)
  20.     params = {
  21.         "b" : B,
  22.         "c" : C
  23.     }
  24.     # build
  25.     targets = {
  26.         tvm.expr.IntImm("int32", ctx.device_type): tgt
  27.     }
  28.     g_json, mmod, params = relay.build(relay.Module.from_expr(func), targets, "llvm", params=params)
  29.     # test
  30.     rt = tvm.contrib.graph_runtime.create(g_json, mmod, ctx)
  31.     rt.set_input("a", A)
  32.     rt.load_params(relay.save_param_dict(params))
  33.     rt.run()
  34.     out = rt.get_output(0)
  35.     np.testing.assert_allclose(out.asnumpy(), np.maximum(np.dot(A.asnumpy(),B.asnumpy().T),0) + C.asnumpy(),atol=1e-5, rtol=1e-5)