Ejemplo n.º 1
0
 def expected():
     x = relay.var("x", shape=(1, 32, 28, 28))
     weight = relay.var("weight")
     x = relay.layout_transform(x, "NCHW", "NCHW4c")
     y = relay.nn.conv2d(x, weight, channels=32, kernel_size=(3, 3), padding=(1, 1),
                         data_layout="NCHW4c")
     y = relay.strided_slice(y, begin=[0, 4], end=[None, 8])
     y = relay.layout_transform(y, "NCHW4c", "NCHW")
     y = relay.Function(free_vars(y), y)
     return y
 def expected():
     x = relay.var("x", shape=(1, 32, 28, 28))
     weight = relay.var("weight")
     x = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(x, weight, channels=32, kernel_size=(3, 3), padding=(1, 1),
                         data_layout="NCHW16c")
     y = relay.nn.upsampling(y, scale_h=2, scale_w=2, layout="NCHW16c")
     y = relay.nn.avg_pool2d(y, pool_size=(2, 2), strides=(2, 2), layout='NCHW16c')
     y = relay.layout_transform(y, "NCHW16c", "NCHW")
     y = relay.Function(analysis.free_vars(y), y)
     return y
 def expected():
     x = relay.var("x", shape=(1, 32, 56, 56))
     w = relay.var("w", shape=(32, 1, 3, 3))
     x = relay.layout_transform(x, "NCHW", "NCHW8c")
     w = relay.layout_transform(w, "OIHW", "OIHW1i8o")
     y = relay.nn.contrib_depthwise_conv2d_nchwc(x, w, padding=(1, 1, 1, 1), channels=32, kernel_size=(3, 3),
                                                 groups=32, data_layout="NCHW8c", kernel_layout="OIHW1i8o",
                                                 out_layout="NCHW8c")
     y = relay.layout_transform(y, "NCHW8c", "NCHW")
     y = relay.Function(analysis.free_vars(y), y)
     return y
Ejemplo n.º 4
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     weight1 = relay.var("weight1")
     y = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(
         y, weight1, channels=32, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
     )
     ret = relay.layout_transform(y, "NCHW16c", "NCHW")
     ret = relay.nn.pad(ret, pad_width=((0, 0), (1, 1), (1, 1), (1, 1)))
     y = relay.Function(analysis.free_vars(ret), ret)
     return y
Ejemplo n.º 5
0
 def expected_nchw():
     x = relay.var("x", shape=(1, 64, 56, 56))
     weight1 = relay.var("weight1")
     y = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(
         y, weight1, channels=32, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
     )
     ret = relay.nn.avg_pool2d(y, pool_size=(1, 1), layout="NCHW16c")
     ret = relay.layout_transform(ret, "NCHW16c", "NCHW")
     y = relay.Function(analysis.free_vars(ret), ret)
     return y
Ejemplo n.º 6
0
 def expected():
     x = relay.var("x", shape=(1, 32, 28, 28))
     weight = relay.var("weight")
     x = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(x, weight, channels=32, kernel_size=(3, 3), padding=(1, 1),
                         data_layout="NCHW16c")
     y = relay.nn.upsampling(y, scale=2, layout="NCHW16c")
     y = relay.nn.avg_pool2d(y, pool_size=(2, 2), strides=(2, 2), layout='NCHW16c')
     y = relay.layout_transform(y, "NCHW16c", "NCHW")
     y = relay.Function(free_vars(y), y)
     return y
Ejemplo n.º 7
0
    def expected():
        x = relay.var("x", shape=(1, 56, 56, 64))
        w = relay.var("weight", shape=(3, 3, 64, 64))
        x = relay.layout_transform(x, "NHWC", "NCHW")
        w = relay.layout_transform(w, "HWIO", "OIHW")
        y = relay.nn.conv2d(x, w, channels=64, kernel_size=(3, 3), padding=(1, 1))
        y = relay.add(y, relay.const(1.0, "float32"))

        y = relay.layout_transform(y, "NCHW", "NHWC")
        y = relay.Function(analysis.free_vars(y), y)
        return y
Ejemplo n.º 8
0
 def expected_nhwc():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight1 = relay.var("weight1")
     y = relay.layout_transform(x, "NHWC", "NCHW16c")
     y = relay.nn.conv2d(
         y, weight1, channels=32, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
     )
     ret = relay.layout_transform(y, "NCHW16c", "NCHW")
     ret = relay.sum(ret, axis=[1], keepdims=True)
     ret = relay.layout_transform(ret, "NCHW", "NHWC")
     y = relay.Function(analysis.free_vars(ret), ret)
     return y
Ejemplo n.º 9
0
    def expected():
        x = relay.var("x", shape=(1, 64, 56, 56))
        w = relay.var("weight")
        alpha = relay.var("alpha", relay.IncompleteType())

        y = relay.layout_transform(x, "NCHW", "NCHW16c")
        y = relay.nn.conv2d(
            y, w, channels=64, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
        )
        y = relay.layout_transform(y, "NCHW16c", "NCHW")
        y = relay.nn.prelu(y, alpha)
        y = relay.Function(analysis.free_vars(y), y)
        return y
Ejemplo n.º 10
0
    def expected():
        x = relay.var("x", shape=(1, 64, 56, 56))
        w = relay.var("weight")

        y = relay.layout_transform(x, "NCHW", "NCHW16c")
        y = relay.nn.conv2d(
            y, w, channels=64, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
        )
        y = relay.add(y, relay.const(1.0, "float32"))

        y = relay.layout_transform(y, "NCHW16c", "NCHW")
        y = relay.Function(analysis.free_vars(y), y)
        return y
 def expected():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight1 = relay.var("weight1", shape=(3, 3, 64, 64))
     weight2 = relay.var("weight2", shape=(3, 3, 64, 64))
     weight1 = relay.layout_transform(weight1, "HWIO", "OIHW")
     weight2 = relay.layout_transform(weight2, "HWIO", "OIHW")
     y = relay.layout_transform(x, "NHWC", "NCHW")
     y = relay.nn.conv2d(y, weight1, channels=64, kernel_size=(3, 3), padding=(1, 1))
     y1 = relay.nn.conv2d(y, weight2, channels=64, kernel_size=(3, 3), padding=(1, 1))
     ret = relay.concatenate([y, y1], axis=1)
     ret = relay.layout_transform(ret, "NCHW", "NHWC")
     y = relay.Function(analysis.free_vars(ret), ret)
     return y
Ejemplo n.º 12
0
 def expected():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight = relay.var('weight', shape=(3, 3, 64, 64))
     x = relay.layout_transform(x, 'NHWC', 'NCHW')
     weight = relay.layout_transform(weight, 'HWIO', 'OIHW')
     y = relay.nn.conv2d(x,
                         weight,
                         channels=64,
                         kernel_size=(3, 3),
                         padding=(1, 1))
     y = relay.nn.relu(y)
     y = relay.layout_transform(y, 'NCHW', 'NHWC')
     y = relay.Function(relay.analysis.free_vars(y), y)
     return y
Ejemplo n.º 13
0
    def expected():
        x = relay.var("x", shape=(1, 32, 28, 28))
        weight = relay.var("weight", shape=(32, 32, 3, 3))
        weight = relay.layout_transform(weight, "OIHW", "OIHW4i4o")
        x = relay.layout_transform(x, "NCHW", "NCHW4c")
        y = relay.op.nn.contrib_conv2d_nchwc(
            x, weight, channels=32, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW4c"
        )

        y = relay.strided_slice(y, begin=[0, 4], end=[1, 21], strides=[1, 1])

        y = relay.layout_transform(y, "NCHW4c", "NCHW")
        y = relay.Function(analysis.free_vars(y), y)
        return y
Ejemplo n.º 14
0
 def expected():
     x = relay.var("x", shape=(1, 32, 28, 28))
     weight = relay.var("weight")
     x = relay.layout_transform(x, "NCHW", "NCHW4c")
     y = relay.nn.conv2d(x,
                         weight,
                         channels=32,
                         kernel_size=(3, 3),
                         padding=(1, 1),
                         data_layout="NCHW4c")
     y = relay.strided_slice(y, begin=[0, 4], end=[None, 8])
     y = relay.layout_transform(y, "NCHW4c", "NCHW")
     y = relay.Function(analysis.free_vars(y), y)
     return y
Ejemplo n.º 15
0
 def expected():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight = relay.var("weight", shape=(3, 3, 64, 64))
     x = relay.layout_transform(x, "NHWC", "NCHW")
     weight = relay.layout_transform(weight, "HWIO", "OIHW")
     y = relay.nn.conv2d_transpose(x,
                                   weight,
                                   channels=64,
                                   kernel_size=(3, 3),
                                   padding=(1, 1))
     y = relay.nn.relu(y)
     y = relay.layout_transform(y, "NCHW", "NHWC")
     y = relay.Function(relay.analysis.free_vars(y), y)
     return y
Ejemplo n.º 16
0
    def expected():
        x = relay.var("x", shape=(1, 64, 56, 56))
        w = relay.var("weight")

        y = relay.layout_transform(x, "NCHW", "NCHW16c")
        y = relay.nn.conv2d(y, w,
                            channels=64,
                            kernel_size=(3, 3),
                            padding=(1, 1),
                            data_layout="NCHW16c")
        y = relay.add(y, relay.const(1.0, "float32"))

        y = relay.layout_transform(y, "NCHW16c", "NCHW")
        y = relay.Function(free_vars(y), y)
        return y
    def before10():
        """
        Simplify layout_transform->layout_transform without rank change to transpose.

        Input:
        NCHW -> NHWC -> CHWN -> op

        Simplified:
        NCHW -> CHWN -> op
        """
        x = relay.var("x", shape=(1, 128, 56, 56), dtype="float32")
        y = relay.layout_transform(x, "NCHW", "NHWC")
        y = relay.layout_transform(y, "NHWC", "CHWN")
        y = relay.nn.relu(y)
        return relay.Function([x], y)
Ejemplo n.º 18
0
    def expected():
        x = relay.var("x", shape=(1, 64, 56, 56))
        w = relay.var("weight")
        alpha = relay.var("alpha", relay.IncompleteType())

        y = relay.layout_transform(x, "NCHW", "NCHW16c")
        y = relay.nn.conv2d(y, w,
                            channels=64,
                            kernel_size=(3, 3),
                            padding=(1, 1),
                            data_layout="NCHW16c")
        y = relay.layout_transform(y, "NCHW16c", "NCHW")
        y = relay.nn.prelu(y, alpha)
        y = relay.Function(free_vars(y), y)
        return y
Ejemplo n.º 19
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     weight1 = relay.var("weight1")
     weight2 = relay.var("weight2")
     x = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(
         x, weight1, channels=32, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
     )
     y = relay.nn.relu(y)
     y2 = relay.nn.conv2d(x, weight2, channels=32, kernel_size=(1, 1), data_layout="NCHW16c")
     y2 = relay.nn.relu(y2)
     y = y + y2
     y = relay.nn.global_max_pool2d(y, layout="NCHW16c")
     y = relay.layout_transform(y, "NCHW16c", "NCHW")
     return relay.Function(analysis.free_vars(y), y)
    def before8():
        """
        Simplify layout_transform->layout_transform with rank contraction and expansion

        Input:
        NCHW4c -> NCHW -> NCHW8c -> op

        Simplified:
        NCHW4c -> NCHW8c -> op
        """
        x = relay.var("x", shape=(1, 32, 56, 56, 4), dtype="float32")
        y = relay.layout_transform(x, "NCHW4c", "NCHW")
        y = relay.layout_transform(y, "NCHW", "NCHW8c")
        y = relay.nn.relu(y)
        return relay.Function([x], y)
Ejemplo n.º 21
0
 def expected_nhwc():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight1 = relay.var('weight1', shape=(3, 3, 64, 64))
     weight2 = relay.var('weight2', shape=(3, 3, 64, 64))
     y = relay.layout_transform(x, "NHWC", "NCHW")
     weight1 = relay.layout_transform(weight1, "HWIO", "OIHW")
     weight2 = relay.layout_transform(weight2, "HWIO", "OIHW")
     y = relay.nn.conv2d(y, weight1, channels=64, kernel_size=(3, 3))
     y = relay.nn.relu(y)
     y = relay.nn.avg_pool2d(y, pool_size=(1, 1))
     y = relay.nn.conv2d(y, weight2, channels=64, kernel_size=(3, 3))
     y = relay.nn.relu(y)
     y = relay.layout_transform(y, "NCHW", "NHWC")
     y = relay.Function(analysis.free_vars(y), y)
     return y
 def expected():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight1 = relay.var("weight1", shape=(3, 3, 64, 32))
     weight2 = relay.var("weight2", shape=(1, 1, 64, 32))
     weight1 = relay.layout_transform(weight1, "HWIO", "OIHW")
     weight2 = relay.layout_transform(weight2, "HWIO", "OIHW")
     x = relay.layout_transform(x, "NHWC", "NCHW")
     y = relay.nn.conv2d(x, weight1, channels=32, kernel_size=(3, 3), padding=(1, 1))
     y = relay.nn.relu(y)
     y2 = relay.nn.conv2d(x, weight2, channels=32, kernel_size=(1, 1))
     y2 = relay.nn.relu(y2)
     y = y + y2
     y = relay.nn.global_max_pool2d(y)
     y = relay.layout_transform(y, "NCHW", "NHWC")
     return relay.Function(analysis.free_vars(y), y)
    def before9():
        """
        Remove trivial layout_transform->layout_transform.

        Input:
        NCHW -> NCHW4c -> NCHW -> op

        Simplified:
        NCHW -> op
        """
        x = relay.var("x", shape=(1, 128, 56, 56), dtype="float32")
        y = relay.layout_transform(x, "NCHW", "NCHW4c")
        y = relay.layout_transform(y, "NCHW4c", "NCHW")
        y = relay.nn.relu(y)
        return relay.Function([x], y)
Ejemplo n.º 24
0
 def expected_nhwc():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight1 = relay.var("weight1")
     weight2 = relay.var("weight2")
     y = relay.layout_transform(x, "NHWC", "NCHW16c")
     y = relay.nn.conv2d(
         y, weight1, channels=32, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
     )
     y1 = relay.nn.conv2d(
         y, weight2, channels=32, kernel_size=(3, 3), padding=(1, 1), data_layout="NCHW16c"
     )
     ret = relay.concatenate([y, y1], axis=1)
     ret = relay.layout_transform(ret, "NCHW16c", "NHWC")
     y = relay.Function(analysis.free_vars(ret), ret)
     return y
Ejemplo n.º 25
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     bias = relay.var("bias", shape=(64,))
     scale = relay.var("scale", shape=(64, 1, 1))
     weight = relay.var("weight")
     x = relay.layout_transform(x, "NCHW", "NCHW16c")
     bias = relay.expand_dims(bias, 1, 2)
     bias = relay.layout_transform(bias, "CHW", "CHW16c")
     scale = relay.layout_transform(scale, "CHW", "CHW16c")
     y = relay.nn.conv2d(x, weight, channels=64, kernel_size=(3, 3), padding=(1, 1),
                         data_layout="NCHW16c")
     y = relay.add(y, bias)          # test broadcasting to lhs
     y = relay.multiply(scale, y)      # test broadcasting to rhs
     y = relay.layout_transform(y, "NCHW16c", "NCHW")
     y = relay.Function(free_vars(y), y)
     return y
Ejemplo n.º 26
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     bias = relay.var("bias", shape=(64,))
     scale = relay.var("scale", shape=(64, 1, 1))
     weight = relay.var("weight")
     x = relay.layout_transform(x, "NCHW", "NCHW16c")
     bias = relay.expand_dims(bias, 1, 2)
     bias = relay.layout_transform(bias, "CHW", "CHW16c")
     scale = relay.layout_transform(scale, "CHW", "CHW16c")
     y = relay.nn.conv2d(x, weight, channels=64, kernel_size=(3, 3), padding=(1, 1),
                         data_layout="NCHW16c")
     y = relay.add(y, bias)          # test broadcasting to lhs
     y = relay.multiply(scale, y)      # test broadcasting to rhs
     y = relay.layout_transform(y, "NCHW16c", "NCHW")
     y = relay.Function(free_vars(y), y)
     return y
 def expected():
     x = relay.var("x", shape=(1, 56, 56, 64))
     weight1 = relay.var("weight1", shape=(3, 3, 64, 32))
     weight2 = relay.var("weight2", shape=(3, 3, 32, 32))
     weight1 = relay.layout_transform(weight1, "HWIO", "OIHW")
     weight2 = relay.layout_transform(weight2, "HWIO", "OIHW")
     y = relay.layout_transform(x, "NHWC", "NCHW")
     y = relay.nn.conv2d(y, weight1, channels=32, kernel_size=(3, 3), padding=(1, 1))
     y = relay.nn.relu(y)
     y1 = relay.nn.conv2d(y, weight2, channels=32, kernel_size=(3, 3), padding=(1, 1))
     y1 = relay.nn.relu(y1)
     y1 = relay.layout_transform(y1, "NCHW", "NHWC")
     y2 = relay.layout_transform(y, "NCHW", "NHWC")
     y2 = relay.nn.batch_flatten(y2)
     ret = relay.Tuple([y1, y2])
     y = relay.Function(analysis.free_vars(ret), ret)
     return y
Ejemplo n.º 28
0
 def dynamic_expected():
     A = relay.var("A", shape=(relay.Any(), k), dtype="float32")
     B = relay.var("B", shape=(n, k), dtype="float32")
     target_layout = "NK16n"
     weight_transform = relay.layout_transform(B, "NK", target_layout)
     y = relay.nn.contrib_dense_pack(A, weight_transform, units=None, out_dtype="float32")
     y = relay.Function(relay.analysis.free_vars(y), y)
     return y
    def before4():
        """
        Simplify transpose->layout_transform and its inverse.

        Input:
        NHWC -> NCHW -> NCHW4c -> op -> NCHW4c -> NCHW -> NHWC

        Simplified:
        NHWC -> NCHW4c -> op -> NCHW4c -> NHWC
        """
        x = relay.var("x", shape=(1, 56, 56, 128), dtype="float32")
        y = relay.transpose(x, axes=[0, 3, 1, 2])
        y = relay.layout_transform(y, "NCHW", "NCHW4c")
        y = relay.nn.relu(y)
        y = relay.layout_transform(y, "NCHW4c", "NCHW")
        y = relay.transpose(y, axes=[0, 2, 3, 1])
        return relay.Function([x], y)
    def before5():
        """
        Simplify layout_transform->layout_transform and its inverse.

        Input:
        NHWC -> NCHW -> NCHW4c -> op -> NCHW4c -> NCHW -> NHWC

        Simplified:
        NHWC -> NCHW4c -> op -> NCHW4c -> NHWC
        """
        x = relay.var("x", shape=(1, 56, 56, 128), dtype="float32")  # NHWC
        y = relay.layout_transform(x, "NHWC", "NCHW")  # To NCHW
        y = relay.layout_transform(y, "NCHW", "NCHW4c")  # To NCHW4c
        y = relay.nn.relu(y)
        y = relay.layout_transform(y, "NCHW4c", "NCHW")  # To NCHW
        y = relay.layout_transform(y, "NCHW", "NHWC")  # To NHWC
        return relay.Function([x], y)
    def expected():
        x = relay.var("x", shape=(1, 56, 56, 64))
        w = relay.var("weight", shape=(3, 3, 64, 64))
        x = relay.layout_transform(x, "NHWC", "NCHW")
        w = relay.layout_transform(w, "HWIO", "OIHW")
        y = relay.nn.conv2d(x, w, channels=64, kernel_size=(3, 3), padding=(1, 1))

        dtype = "float32"
        beta = relay.var("beta", relay.TensorType((64,), dtype))
        gamma = relay.var("gamma", relay.TensorType((64,), dtype))
        moving_mean = relay.var("moving_mean", relay.TensorType((64,), dtype))
        moving_var = relay.var("moving_var", relay.TensorType((64,), dtype))

        y = relay.nn.batch_norm(y, gamma, beta, moving_mean, moving_var, axis=1)
        y = relay.nn.relu(y[0])
        y = relay.layout_transform(y, "NCHW", "NHWC")
        y = relay.Function(analysis.free_vars(y), y)
        return y
    def expected():
        x = relay.var("x", shape=(1, 64, 56, 56))
        bias = relay.var("bias", shape=(64,))
        weight = relay.var("weight", shape=(64, 64, 3, 3))

        y = relay.layout_transform(x, "NCHW", "NCHW16c")
        w = relay.layout_transform(weight, "OIHW", "OIHW16i")
        y = relay.nn.conv2d(y, w,
                            channels=64,
                            kernel_size=(3, 3),
                            padding=(1, 1),
                            kernel_layout="OIHW16i",
                            data_layout="NCHW16c")
        y = relay.nn.max_pool2d(y, pool_size=(2, 2), layout="NCHW16c")
        y = relay.layout_transform(y, "NCHW16c", "NCHW")
        y = relay.nn.lrn(y)
        y = relay.Function(analysis.free_vars(y), y)
        return y
Ejemplo n.º 33
0
def verify_any_layout_transform(data_shape, src_layout, dst_layout,
                                static_data_shape, ref_out_shape):
    mod = tvm.IRModule()
    dtype = "float32"
    data = relay.var("data", shape=data_shape, dtype=dtype)
    y = relay.layout_transform(data, src_layout, dst_layout)
    mod["main"] = relay.Function([data], y)
    data_np = np.random.uniform(size=static_data_shape).astype(dtype)
    check_result([data_np], mod, ref_out_shape, assert_shape=True)
Ejemplo n.º 34
0
 def expected():
     x = relay.var("x", shape=(1, 56, 56, 64), dtype="int8")
     weight1 = relay.var("weight1", shape=(3, 3, 64, 64), dtype="int8")
     weight2 = relay.var("weight2", shape=(3, 3, 64, 64), dtype="int8")
     weight1 = relay.layout_transform(weight1, "HWIO", "OIHW")
     weight2 = relay.layout_transform(weight2, "HWIO", "OIHW")
     y = relay.layout_transform(x, "NHWC", "NCHW")
     y = relay.qnn.op.conv2d(
         y,
         weight1,
         relay.const(1, "int32"),
         relay.const(1, "int32"),
         relay.const(1, "float32"),
         relay.const(1, "float32"),
         channels=64,
         kernel_size=(3, 3),
         padding=(1, 1),
     )
     y1 = relay.qnn.op.conv2d(
         y,
         weight2,
         relay.const(1, "int32"),
         relay.const(1, "int32"),
         relay.const(1, "float32"),
         relay.const(1, "float32"),
         channels=64,
         kernel_size=(3, 3),
         padding=(1, 1),
     )
     y = relay.cast(y, "int8")
     y1 = relay.cast(y, "int8")
     ret = relay.qnn.op.add(
         y,
         y1,
         relay.const(1, "float32"),
         relay.const(1, "int32"),
         relay.const(1, "float32"),
         relay.const(1, "int32"),
         relay.const(1, "float32"),
         relay.const(1, "int32"),
     )
     ret = relay.layout_transform(ret, "NCHW", "NHWC")
     y = relay.Function(analysis.free_vars(ret), ret)
     return y
Ejemplo n.º 35
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     weight1 = relay.var('weight1')
     weight2 = relay.var('weight2')
     y = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(y, weight1,
                         channels=32,
                         kernel_size=(3, 3),
                         padding=(1, 1),
                         data_layout="NCHW16c")
     y1 = relay.nn.conv2d(y, weight2,
                          channels=32,
                          kernel_size=(3, 3),
                          padding=(1, 1),
                          data_layout='NCHW16c')
     ret = relay.concatenate([y, y1], axis=1)
     ret = relay.layout_transform(ret, "NCHW16c", "NCHW")
     y = relay.Function(free_vars(ret), ret)
     return y
Ejemplo n.º 36
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     weight1 = relay.var('weight1')
     weight2 = relay.var('weight2')
     y = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(y, weight1,
                         channels=32,
                         kernel_size=(3, 3),
                         padding=(1, 1),
                         data_layout="NCHW16c")
     y1 = relay.nn.conv2d(y, weight2,
                          channels=32,
                          kernel_size=(3, 3),
                          padding=(1, 1),
                          data_layout='NCHW16c')
     ret = relay.concatenate([y, y1], axis=1)
     ret = relay.layout_transform(ret, "NCHW16c", "NCHW")
     y = relay.Function(free_vars(ret), ret)
     return y
Ejemplo n.º 37
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     weight1 = relay.var('weight1')
     weight2 = relay.var('weight2')
     x = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(x, weight1,
                         channels=32,
                         kernel_size=(3, 3),
                         padding=(1, 1),
                         data_layout="NCHW16c")
     y = relay.nn.relu(y)
     y2 = relay.nn.conv2d(x, weight2,
                          channels=32,
                          kernel_size=(1, 1),
                          data_layout='NCHW16c')
     y2 = relay.nn.relu(y2)
     y = y + y2
     y = relay.nn.global_max_pool2d(y, layout="NCHW16c")
     y = relay.layout_transform(y, "NCHW16c", "NCHW")
     return relay.Function(free_vars(y), y)
Ejemplo n.º 38
0
 def expected():
     x = relay.var("x", shape=(1, 64, 56, 56))
     weight1 = relay.var('weight1')
     weight2 = relay.var('weight2')
     y = relay.layout_transform(x, "NCHW", "NCHW16c")
     y = relay.nn.conv2d(y, weight1,
                         channels=32,
                         kernel_size=(3, 3),
                         padding=(1, 1),
                         data_layout="NCHW16c")
     y = relay.nn.relu(y)
     y1 = relay.nn.conv2d(y, weight2,
                          channels=32,
                          kernel_size=(3, 3),
                          padding=(1, 1),
                          data_layout='NCHW16c')
     y1 = relay.nn.relu(y1)
     y1 = relay.layout_transform(y1, "NCHW16c", "NCHW")
     y2 = relay.layout_transform(y, "NCHW16c", "NCHW")
     y2 = relay.nn.batch_flatten(y2)
     ret = relay.Tuple([y1, y2])
     y = relay.Function(free_vars(ret), ret)
     return y
Ejemplo n.º 39
0
    def expected():
        x = relay.var("x", shape=(1, 64, 56, 56))
        bias = relay.var("bias", shape=(64,))
        weight = relay.var("weight", shape=(64, 64, 3, 3))

        y = relay.layout_transform(x, "NCHW", "NCHW16c")
        w = relay.layout_transform(weight, "OIHW", "OIHW16i")
        y = relay.nn.conv2d(y, w,
                            channels=64,
                            kernel_size=(3, 3),
                            padding=(1, 1),
                            kernel_layout="OIHW16i",
                            data_layout="NCHW16c")
        b = relay.expand_dims(bias, axis=1, num_newaxis=2)
        b = relay.layout_transform(b, "CHW", "CHW16c")
        y = relay.add(y, b)

        y = relay.nn.relu(y)
        y = relay.nn.max_pool2d(y, pool_size=(2, 2), layout="NCHW16c")
        y = relay.cast(y, 'int32')
        y = relay.layout_transform(y, "NCHW16c", "NCHW")
        y = relay.nn.batch_flatten(y)
        y = relay.Function(free_vars(y), y)
        return y