def eval_partial(inp, oup):
if not isinstance(oup, (list, tuple)):
oup = (oup, )
inputs = cgtools.get_dep_vars(oup, "Host2DeviceCopy")
if mge_version <= "0.6.0":
cg = oup[0].owner_graph
outputs = list(map(mgb.copy_output, oup))
f = cg.compile(inputs, outputs)
result = f(inp)
else:
if not isinstance(inp, (list, tuple)):
inp = (inp, )
replace_dict = {}
inp_node_list = []
for i in inputs:
inp_node = G.InputNode(device="xpux",
dtype=inputs[0].dtype,
graph=inputs[0].graph)
replace_dict[i] = inp_node.outputs[0]
inp_node_list.append(inp_node)
new_out = cgtools.replace_vars(oup, replace_dict)
out_node_list = [G.OutputNode(i) for i in new_out]
new_out_list = [i.outputs[0] for i in out_node_list]
cg = new_out_list[0].graph
func = cg.compile(new_out_list)
for node, value in zip(inp_node_list, inp):
node.set_value(Tensor(value)._dev_tensor())
func.execute()
result = [o.get_value().numpy() for o in out_node_list]
return result
def _get_compiled_result(inp, dtype, shape, device, calc_func=None):
graph = G.Graph()
# graph.options.async_exec_level = 0b100
inp_node = G.InputNode(device=device, dtype=dtype, shape=shape, graph=graph)
temp_rst = calc_func(inp_node.outputs[0])
oup_node = G.OutputNode(temp_rst)
func = graph.compile(oup_node.outputs[0])
inp_node.set_value(as_raw_tensor(inp, dtype=dtype, device=device)._dev_tensor())
func.execute()
return oup_node.get_value().numpy()
def test_io2():
g = mgb_graph.Graph()
g.options.async_exec_level = 0b100
dtype, device = "float32", "xpux"
px = mgb_graph.InputNode(device=device, dtype=dtype, graph=g)
py = mgb_graph.OutputNode(px.outputs[0])
f = g.compile(py.outputs[0])
for _ in range(3):
f.execute()
x = Tensor(np.random.randn(10).astype(dtype), device=device)._dev_tensor()
px.set_value(x)
y = py.get_value()
np.testing.assert_equal(x.numpy(), y.numpy())
f.wait()
def test_attr_output():
g = mgb_graph.Graph()
g.options.async_exec_level = 0b100
dtype, device = "float32", "xpux"
px = mgb_graph.InputNode(device=device, dtype=dtype, graph=g)
py = mgb_graph.AttrOutputNode(px.outputs[0])
f = g.compile(py.outputs[0])
for shape in [(2,), (3,), (5,)]:
f.execute()
x = Tensor(np.random.randn(*shape).astype(dtype), device=device)._dev_tensor()
px.set_value(x)
ay = py.get_value()
assert ay.shape == shape
assert ay.dtype == np.dtype(dtype)
assert ay.device == device
f.wait()
def test_replace_vars():
g = mgb_graph.Graph()
g.options.async_exec_level = 0b100
device = "xpux"
dtype = np.float32
a = mgb_graph.InputNode(device=device, dtype=dtype, graph=g)
const = g.make_const(1.234)
a_plus_a = F.add(a.outputs[0], a.outputs[0])
a_plus_a_mul_const = F.mul(a_plus_a, const)
rst = F.add(a_plus_a_mul_const, a.outputs[0])
(new, ) = cgtools.replace_vars([rst._node], {const._node: a_plus_a._node})
out = mgb_graph.OutputNode(mgb_graph.VarNode(new))
func = g.compile(out.outputs[0])
func.execute()
x = make_dev_tensor(5.0, device=device)
a.set_value(x)
res = out.get_value().numpy()
np.testing.assert_equal(res, np.array([105.0]))
def test_replace_oprs():
g = mgb_graph.Graph()
g.options.async_exec_level = 0b100
device = "xpux"
dtype = np.float32
a = mgb_graph.InputNode(device=device, dtype=dtype, graph=g)
const = g.make_const(1.25, device=device)
add_op = Elemwise(Elemwise.Mode.ADD)
mul_op = Elemwise(Elemwise.Mode.MUL)
a_plus_a = apply_normal_varnode(add_op, a.outputs[0], a.outputs[0])[0]
old_opr = a_plus_a.op
a_plus_a_mul_const = apply_normal_varnode(mul_op, a_plus_a, const)[0]
a_mul_a = apply_normal_varnode(mul_op, a.outputs[0], a.outputs[0])[0]
new_opr = a_mul_a.op
(new, ) = cgtools.replace_oprs([a_plus_a_mul_const._node],
{old_opr._node: new_opr._node})
out = mgb_graph.OutputNode(mgb_graph.VarNode(new))
func = g.compile(out.outputs[0])
func.execute()
x = make_dev_tensor(5.0, device=device)
a.set_value(x)
res = out.get_value().numpy()
np.testing.assert_equal(res, np.array([5.0 * 5.0 * 1.25]))
def make_feeds(args):
cg_rt, _, outputs = G.load_graph(args.input)
inputs = cgtools.get_dep_vars(outputs, "Host2DeviceCopy")
inputs = {i.name: i for i in inputs}
if not args.no_assert:
replace_varmap = {}
inp_map = {}
# replace var use InputNode
for name, var in inputs.items():
inp = G.InputNode(device="xpux",
dtype=var.dtype,
shape=var.shape,
graph=cg_rt)
replace_varmap[var] = inp.outputs[0]
inp_map[name] = inp
new = cgtools.replace_vars(outputs, replace_varmap)
if isinstance(new, rt.VarNode):
new = list(new)
output_nodes = [G.OutputNode(var) for var in new]
func = cg_rt.compile([node.outputs[0] for node in output_nodes])
def make_dev_tensor(value, dtype=None, device=None):
return as_raw_tensor(value, dtype=dtype,
device=device)._dev_tensor()
def calculate(*args, **kwargs):
output_val = []
# set inputs value
for name, var in inputs.items():
val = kwargs.pop(name, None)
assert val is not None, "miss input name{}".format(name)
dev_tensor = make_dev_tensor(val,
dtype=var.dtype,
device="xpux")
inp_map[name].set_value(dev_tensor)
func.execute()
for res in output_nodes:
output_val.append(res.get_value().numpy())
return output_val
def expect_name(var):
return "{}:expect".format(var.name)
testcases = []
np.set_printoptions(precision=2, threshold=4, suppress=True)
data_list = []
for item in args.data:
if item.startswith("@"):
with open(item[1:], "r") as f:
data_list.extend(
[line.rstrip() for line in f if line.rstrip() != ""])
else:
data_list.append(item)
for inp_spec in data_list:
cur_testcase = gen_one_testcase(args, inputs, inp_spec)
assert len(cur_testcase) == len(
inputs), "required inputs: {}; given data: {}".format(
inputs.keys(), cur_testcase.keys())
if not args.no_assert:
outputs_get = calculate(**cur_testcase)
for var, val in zip(outputs, outputs_get):
cur_testcase[expect_name(var)] = val
logger.info(
"generate test groundtruth: var={} shape={} range=({}, {})"
" mean={} var={}".format(var, val.shape, val.min(),
val.max(), np.mean(val),
np.var(val)))
testcases.append(cur_testcase)
logger.info("add testcase: \n {}".format("\n ".join(
"{}: shape={} dtype={} range=({:.2f},{:.2f}) "
"mean={:.2f} sd={:.2f}".format(k, v.shape, v.dtype, v.min(),
v.max(), np.mean(v), np.std(v))
for k, v in sorted(cur_testcase.items()))))
if not args.no_assert:
def expect_shp(var):
ret = var.shape
if ret:
return ret
return testcases[0][expect_name(var)].shape
def assert_equal(expect, real, **kwargs):
op = builtin.AssertEqual(**kwargs)
(res, ) = apply(op, expect, real)
return res
verbose = not args.silent
outputs_new = []
for i in outputs:
device = rt.CompNode("xpux")
dtype = i.dtype
name = expect_name(i)
shape = expect_shp(i)
# make expect output as one input of model.
expect_get = rt.make_h2d(cg_rt, device, dtype, shape, name)
# insert assert opr to check expect and real.
outputs_new.append(
assert_equal(
G.VarNode(expect_get),
G.VarNode(i),
verbose=verbose,
maxerr=args.maxerr,
))
inputs[expect_name(i)] = expect_get
outputs = outputs_new
return cg_rt, {"outputs": outputs, "testcases": testcases}
