前向折叠 dense 的测试用例

%cd ..
import set_env

/media/pc/data/lxw/ai/tvm-book/tests/book/doc/tests

import numpy as np

import tvm
from tvm import relay
from tvm.relay import transform
# from tvm.relay.testing import create_workload
# from tvm.relay.build_module import bind_params_by_name


def initializer(_, param):
    param = np.zeros(param.shape)


def _get_positive_scale(size):
    return np.random.uniform(0.5, 1, size=size).astype("float32")


def run_opt_pass(expr, opt_pass):
    assert isinstance(opt_pass, tvm.transform.Pass)
    mod = tvm.IRModule.from_expr(expr)
    mod = opt_pass(mod)
    entry = mod["main"]
    return entry if isinstance(expr, relay.Function) else entry.body

def before(x, weight, in_bias, in_scale):
    args = [x, weight, in_bias]
    x = relay.multiply(x, in_scale)
    x = relay.nn.relu(x)
    x = relay.add(x, in_bias)
    y = relay.nn.dense(x, weight)
    return relay.Function(args, y)

def expected(x, weight, in_bias, in_scale):
    # use a fixed order of args so alpha equal check can pass
    args = [x, weight, in_bias]
    x = relay.nn.relu(x)
    in_bias = relay.divide(in_bias, in_scale)
    x = relay.add(x, in_bias)
    weight = relay.multiply(weight, in_scale)
    y = relay.nn.dense(x, weight)
    return relay.Function(args, y)

def check(data_shape, weight_shape):
    x = relay.var("x", shape=data_shape)
    weight = relay.var("weight", shape=weight_shape)
    in_channels = data_shape[1]
    in_bias = relay.var("in_bias", shape=(in_channels,))
    in_scale = relay.const(_get_positive_scale((in_channels,)))
    y1 = before(x, weight, in_bias, in_scale)
    y1 = run_opt_pass(y1, transform.InferType())
    print("FoldScaleAxis 前：")
    tvm.IRModule.from_expr(y1).show()

    y1_folded = run_opt_pass(y1, transform.ForwardFoldScaleAxis())
    y1_expected = expected(x, weight, in_bias, in_scale)

    y1_folded = run_opt_pass(y1_folded, transform.InferType())
    print("FoldScaleAxis 后：")
    tvm.IRModule.from_expr(y1_folded).show()
    
    y1_expected = run_opt_pass(y1_expected, transform.InferType())
    tvm.ir.assert_structural_equal(y1_folded, y1_expected)

check((2, 4), (3, 4))
check((3, 5), (4, 5))

FoldScaleAxis 前：
FoldScaleAxis 后：
FoldScaleAxis 前：
FoldScaleAxis 后：

def @main(%x: Tensor[(2, 4), float32] /* ty=Tensor[(2, 4), float32] */, %weight: Tensor[(3, 4), float32] /* ty=Tensor[(3, 4), float32] */, %in_bias: Tensor[(4), float32] /* ty=Tensor[(4), float32] */) -> Tensor[(2, 3), float32] {
  %0 = multiply(%x, meta[relay.Constant][0] /* ty=Tensor[(4), float32] */) /* ty=Tensor[(2, 4), float32] */;
  %1 = nn.relu(%0) /* ty=Tensor[(2, 4), float32] */;
  %2 = add(%1, %in_bias) /* ty=Tensor[(2, 4), float32] */;
  nn.dense(%2, %weight, units=None) /* ty=Tensor[(2, 3), float32] */
}

def @main(%x: Tensor[(2, 4), float32] /* ty=Tensor[(2, 4), float32] */, %weight: Tensor[(3, 4), float32] /* ty=Tensor[(3, 4), float32] */, %in_bias: Tensor[(4), float32] /* ty=Tensor[(4), float32] */) -> Tensor[(2, 3), float32] {
  %0 = nn.relu(%x) /* ty=Tensor[(2, 4), float32] */;
  %1 = divide(%in_bias, meta[relay.Constant][0] /* ty=Tensor[(4), float32] */) /* ty=Tensor[(4), float32] */;
  %2 = add(%0, %1) /* ty=Tensor[(2, 4), float32] */;
  %3 = multiply(%weight, meta[relay.Constant][0] /* ty=Tensor[(4), float32] */) /* ty=Tensor[(3, 4), float32] */;
  nn.dense(%2, %3, units=None) /* ty=Tensor[(2, 3), float32] */
}

def @main(%x: Tensor[(3, 5), float32] /* ty=Tensor[(3, 5), float32] */, %weight: Tensor[(4, 5), float32] /* ty=Tensor[(4, 5), float32] */, %in_bias: Tensor[(5), float32] /* ty=Tensor[(5), float32] */) -> Tensor[(3, 4), float32] {
  %0 = multiply(%x, meta[relay.Constant][0] /* ty=Tensor[(5), float32] */) /* ty=Tensor[(3, 5), float32] */;
  %1 = nn.relu(%0) /* ty=Tensor[(3, 5), float32] */;
  %2 = add(%1, %in_bias) /* ty=Tensor[(3, 5), float32] */;
  nn.dense(%2, %weight, units=None) /* ty=Tensor[(3, 4), float32] */
}

def @main(%x: Tensor[(3, 5), float32] /* ty=Tensor[(3, 5), float32] */, %weight: Tensor[(4, 5), float32] /* ty=Tensor[(4, 5), float32] */, %in_bias: Tensor[(5), float32] /* ty=Tensor[(5), float32] */) -> Tensor[(3, 4), float32] {
  %0 = nn.relu(%x) /* ty=Tensor[(3, 5), float32] */;
  %1 = divide(%in_bias, meta[relay.Constant][0] /* ty=Tensor[(5), float32] */) /* ty=Tensor[(5), float32] */;
  %2 = add(%0, %1) /* ty=Tensor[(3, 5), float32] */;
  %3 = multiply(%weight, meta[relay.Constant][0] /* ty=Tensor[(5), float32] */) /* ty=Tensor[(4, 5), float32] */;
  nn.dense(%2, %3, units=None) /* ty=Tensor[(3, 4), float32] */
}