def test_mul_param():
x = relay.var('x', shape=(10, 10))
y = relay.var('y', shape=(1, 10))
func = relay.Function([x, y], op.multiply(x, y))
x_data = np.random.rand(10, 10).astype('float32')
y_data = np.random.rand(1, 10).astype('float32')
check_eval(func, [x_data, y_data], x_data * y_data)
def _multiply(children, attrs, odtype='float32'):
if len(children) == 1:
left = children[0]
scalar = attrs.get_float('scalar')
right = relay.const(scalar, dtype=odtype)
else:
assert len(children) == 2
left = children[0]
right = children[1]
return op.multiply(left, right)
def compute(self, input_size, hidden_size, output_size):
self.category_var = category = relay.var('category',
shape=(1, data.N_CATEGORIES))
self.inp_topi_var = inp_topi = relay.var('input',
shape=(),
dtype='int32')
self.hidden_var = hidden = relay.var('hidden', shape=(1, hidden_size))
self.hidden = initialize(self.hidden_var)
n_letter = relay.const(data.N_LETTERS)
one_diag = relay.const(np.diag(np.ones(58)).astype('float32'))
boxed_one = relay.const(np.array([1]).astype('int32'))
inp = op.take(one_diag, op.multiply(boxed_one, inp_topi), axis=0)
combined = op.concatenate(
[op.concatenate([category, inp], axis=1), hidden], axis=1)
hidden = self.linear(data.N_CATEGORIES + input_size + hidden_size,
hidden_size,
combined,
name='i2h')
output = self.linear(data.N_CATEGORIES + input_size + hidden_size,
output_size,
combined,
name='i2o')
output_combined = op.concatenate([hidden, output], axis=1)
output = self.linear(hidden_size + output_size,
output_size,
output_combined,
name='o2o')
# output = op.nn.dropout(output, 0.1) #attributes has not been registered
output = op.nn.log_softmax(output, axis=1)
topi = op.argmax(output)
body = relay.Tuple([
hidden, topi,
op.equal(topi, op.subtract(n_letter, relay.const(1)))
])
fwd_para = [self.category_var, self.inp_topi_var, self.hidden_var]
fwd_func = relay.Function(fwd_para, body)
self.fwd = relay.Var('fwd')
max = relay.var('max', shape=(), dtype='int32')
inp_para = [max] + [copy_var(v) for v in fwd_para]
fwd_res = self.fwd(*inp_para[1:])
fwd_res_0 = relay.TupleGetItem(fwd_res, 0)
fwd_res_1 = relay.TupleGetItem(fwd_res, 1)
fwd_res_2 = relay.TupleGetItem(fwd_res, 2)
else_else_branch = self.prelude.cons(
fwd_res_1,
self.recurse(op.subtract(max, relay.const(1)), inp_para[1],
fwd_res_1, fwd_res_0))
else_branch = relay.If(fwd_res_2, self.prelude.nil(), else_else_branch)
body = relay.If(op.equal(max, relay.const(0)), self.prelude.nil(),
else_branch)
return inp_para, relay.Let(self.fwd, fwd_func, body), None
def aten_mul(inputs, attributes, scope):
# print_inputs(inputs)
lfs, rfs = inputs
ctx = current_context()
net = ctx.network
if ctx.is_tensorrt and has_trt_tensor(inputs):
output = _scale_or_elementwise(net, lfs, rfs, "mul", scope)
output.name = scope
return [output]
elif ctx.is_tvm and has_tvm_tensor(inputs):
lfs, rfs = _tvm_to_const([lfs, rfs])
return [_op.multiply(lfs, rfs)]
return [lfs * rfs]
def _mx_masked_softmax(inputs, attrs):
assert len(inputs) == 1 or len(inputs) == 2
axis = attrs.get_int("axis")
temperature = attrs.get_float("temperature")
if len(inputs) == 1:
result = _op.nn.softmax(inputs[0] / _expr.const(temperature),
axis=axis)
else:
neg = -1e18
att_score, mask = inputs
att_score_dtype = _infer_type(att_score).checked_type.dtype
if att_score_dtype == "float16":
neg = -1e4
temp = _op.where(mask, att_score, _expr.const(neg))
result = _op.multiply(
_op.nn.softmax(temp / _expr.const(temperature), axis=axis),
mask.astype("float32"))
return result
def test_pass_profiler():
x, y, z = [tvm.relay.var(c, shape=(3, 4), dtype="float32") for c in "xyz"]
e1 = op.add(x, y)
e2 = op.subtract(x, z)
e3 = op.multiply(e1, e1 / e2)
mod = tvm.IRModule.from_expr(e3 + e2)
tvm.transform.enable_pass_profiling()
mod = tvm.relay.transform.AnnotateSpans()(mod)
mod = tvm.relay.transform.ToANormalForm()(mod)
mod = tvm.relay.transform.InferType()(mod)
profiles = tvm.transform.render_pass_profiles()
assert "AnnotateSpans" in profiles
assert "ToANormalForm" in profiles
assert "InferType" in profiles
tvm.transform.clear_pass_profiles()
tvm.transform.disable_pass_profiling()
def get_test_model():
x, y, z = [tvm.relay.var(c, shape=(3, 4), dtype="float32") for c in "xyz"]
e1 = op.add(x, y)
e2 = op.subtract(x, z)
e3 = op.multiply(e1, e1 / e2)
return tvm.IRModule.from_expr(e3 + e2)
