Function test_define_subroutine

tests/python/relax/test_testing_nn.py:62–119

Define subroutines when nn.Module.define_subroutine is True

()

def test_define_subroutine():
    """Define subroutines when nn.Module.define_subroutine is True"""

    class Activation(nn.Module):
        define_subroutine = True

        def forward(self, state: relax.Expr) -> relax.Var:
            return relax.op.nn.relu(state)

    class Layer(nn.Module):
        define_subroutine = True

        def __init__(self, in_features, out_features):
            self.weights = nn.Parameter(
                (in_features, out_features), dtype="float32", name="weights"
            )
            self.activation = Activation()

        def forward(self, input: relax.Expr) -> relax.Var:
            state = relax.op.matmul(input, self.weights)
            return self.activation(state)

    @I.ir_module
    class Expected:
        @R.function
        def main(
            state: R.Tensor(("batch_size", 64), dtype="float32"),
            weights: R.Tensor((64, 32), dtype="float32"),
        ) -> R.Tensor(("batch_size", 32), dtype="float32"):
            state = Expected.layer(state, weights)
            return state

        @R.function(private=True)
        def layer(
            state: R.Tensor(("batch_size", 64), dtype="float32"),
            weights: R.Tensor((64, 32), dtype="float32"),
        ) -> R.Tensor(("batch_size", 32), dtype="float32"):
            state = R.matmul(state, weights)
            state = Expected.activation(state)
            return state

        @R.function(private=True)
        def activation(state: R.Tensor(("batch_size", 32), dtype="float32")) -> R.Tensor(
            ("batch_size", 32), dtype="float32"
        ):
            state = R.nn.relu(state)
            return state

    model = Layer(64, 32)
    batch_size = tvm.tirx.Var("batch_size", "int64")
    input = nn.Placeholder((batch_size, 64), dtype="float32", name="input")

    bb = relax.BlockBuilder()
    with bb.function("main", params=[input, *model.parameters()]):
        output = model(input)
        bb.emit_func_output(output)

    tvm.ir.assert_structural_equal(Expected, bb.get())